<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Db4objects.Db4o</name>
    </assembly>
    <members>
        <member name="T:Db4objects.Db4o.Activation.IActivator">
            <summary>
            Activator interface.<br/>
            <br/><br/>
            <see cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</see>
            objects need to have a reference to
            an Activator implementation, which is called
            by Transparent Activation, when a request is received to
            activate the host object.
            </summary>
            <seealso><a href="http://developer.db4o.com/resources/view.aspx/reference/Object_Lifecycle/Activation/Transparent_Activation_Framework">Transparent Activation framework.</a>
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Activation.IActivator.Activate(Db4objects.Db4o.Activation.ActivationPurpose)">
            <summary>Method to be called to activate the host object.</summary>
            <remarks>Method to be called to activate the host object.</remarks>
            <param name="purpose">
            for which purpose is the object being activated?
            <see cref="F:Db4objects.Db4o.Activation.ActivationPurpose.Write">ActivationPurpose.Write</see>
            will cause the object
            to be saved on the next
            <see cref="M:Db4objects.Db4o.IObjectContainer.Commit">Db4objects.Db4o.IObjectContainer.Commit()
            	</see>
            operation.
            </param>
        </member>
        <member name="T:Db4objects.Db4o.Collections.ArrayDictionary4`2">
            <summary>Transparent activatable IDictionary implementation.
            </summary>
            <remarks>
            Transparent activatable IDictionary implementation. Implements IDictionary interface
            using two arrays to store keys and values.
            <br/>
            <br/>
            When instantiated as a result of a query, all the internal members
            are NOT activated at all. When internal members are required to
            perform an operation, the instance transparently activates all the
            members.
            </remarks>
            <seealso cref="!:System.Collections.Generic.IDictionary">System.Collections.IDictionary
            </seealso>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="T:Db4objects.Db4o.TA.IActivatable">
            <summary>
            IActivatable must be implemented by classes in order to support
            Transparent Activation.
            <br/>
            <br/>
            The IActivatable interface may be added to persistent classes by hand
            or by using the db4o instrumentation (Db4oTools).
            </summary>
            <remarks>
            IActivatable must be implemented by classes in order to support
            Transparent Activation.
            <br/>
            <br/>
            The IActivatable interface may be added to persistent classes by hand
            or by using the db4o instrumentation (Db4oTools). For further
            information on the enhancer see:
            <br/>
            <br/>
            http://developer.db4o.com/Resources/view.aspx/Reference/Implementation_Strategies/Enhancement_Tools/Enhancement_For_.NET.
            <br/>
            <br/>
            The basic idea for Transparent Activation is as follows:
            <br/>
            Objects have an activation depth of 0, i.e. by default they are not
            activated at all. Whenever a method is called on such an object, the
            first thing to do before actually executing the method body is to
            activate the object to level 1, i.e. populating its direct members.
            <br/>
            <br/>
            To illustrate this approach, we will use the following simple class.
            <br/>
            <br/>
            <code>
            public class Item {
            <br/>   private Item _next;<br/><br/>
               public Item(Item next) {<br/>
                  _next = next;<br/>
               }<br/><br/>
               public Item Next {<br/>
                 get {<br/>
                  return _next;<br/>
                 }<br/>
               }<br/>
            }<br/><br/></code>
            The basic sequence of actions to get the above scheme to work is the
            following:<br/>
            <br/>
            - Whenever an object is instantiated from db4o, the database registers an
            activator for this object. To enable this, the object has to implement the
            IActivatable interface and provide the according Bind(IActivator) method. The
            default implementation of the bind method will simply store the given
            activator reference for later use.<br/>
            <br/>
            <code>
            public class Item implements IActivatable {<br/>
               transient IActivator _activator;<br/><br/>
               public void Bind(IActivator activator) {<br/>
                  if (null != _activator) {<br/>
                     throw new IllegalStateException();<br/>
                  }<br/>
                  _activator = activator;<br/>
               }<br/><br/>
               // ...<br/>
            }<br/><br/></code>
            - The first action in every method body of an activatable object should be a
            call to the corresponding IActivator's Activate() method. (Note that this is
            not enforced by any interface, it is rather a convention, and other
            implementations are possible.)<br/>
            <br/>
            <code>
            public class Item implements IActivatable {<br/>
               public void Activate() {<br/>
                  if (_activator == null) return;<br/>
                  _activator.Activate();<br/>
               }<br/><br/>
               public Item Next() {<br/>
                 get {<br/>
                  Activate();<br/>
                  return _next;<br/>
                 }<br/>
               }<br/>
            }<br/><br/></code>
            - The Activate() method will check whether the object is already activated.
            If this is not the case, it will request the container to activate the object
            to level 1 and set the activated flag accordingly.<br/>
            <br/>
            To instruct db4o to actually use these hooks (i.e. to register the database
            when instantiating an object), TransparentActivationSupport has to be
            registered with the db4o configuration.<br/>
            <br/>
            <code>
            ICommonConfiguration config = ...<br/>
            config.Add(new TransparentActivationSupport());<br/><br/>
            </code>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.TA.IActivatable.Bind(Db4objects.Db4o.Activation.IActivator)">
            <summary>called by db4o upon instantiation.</summary>
            <remarks>
            called by db4o upon instantiation. <br/>
            <br/>
            The recommended implementation of this method is to store the passed
            <see cref="T:Db4objects.Db4o.Activation.IActivator">Db4objects.Db4o.Activation.IActivator
            	</see>
            in a transient field of the object.
            </remarks>
            <param name="activator">the Activator</param>
        </member>
        <member name="M:Db4objects.Db4o.TA.IActivatable.Activate(Db4objects.Db4o.Activation.ActivationPurpose)">
            <summary>should be called by every reading field access of an object.</summary>
            <remarks>
            should be called by every reading field access of an object. <br/>
            <br/>
            The recommended implementation of this method is to call
            <see cref="M:Db4objects.Db4o.Activation.IActivator.Activate(Db4objects.Db4o.Activation.ActivationPurpose)">Db4objects.Db4o.Activation.IActivator.Activate(Db4objects.Db4o.Activation.ActivationPurpose)
            	</see>
            on the
            <see cref="T:Db4objects.Db4o.Activation.IActivator">Db4objects.Db4o.Activation.IActivator
            	</see>
            that was previously passed to
            <see cref="M:Db4objects.Db4o.TA.IActivatable.Bind(Db4objects.Db4o.Activation.IActivator)">Bind(Db4objects.Db4o.Activation.IActivator)
            	</see>
            .
            </remarks>
            <param name="purpose">TODO</param>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayDictionary4`2.#ctor">
            <summary>
            Initializes a new collection with the initial capacity = 16.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayDictionary4`2.#ctor(System.Int32)">
            <summary>
            Initializes a collection of the specified initial capacity.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayDictionary4`2.Activate(Db4objects.Db4o.Activation.ActivationPurpose)">
            <summary>activate basic implementation.</summary>
            <remarks>activate basic implementation.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayDictionary4`2.Bind(Db4objects.Db4o.Activation.IActivator)">
            <summary>bind basic implementation.</summary>
            <remarks>bind basic implementation.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayDictionary4`2.Clear">
            <summary> System.Collections.Generic.IDictionary implementation but transparently activates
            the members as required.</summary>
            <remarks> System.Collections.Generic.IDictionary implementation but transparently activates
            the members as required.</remarks>
            <seealso cref="!:System.Collections.Generic.IDictionary"/>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayDictionary4`2.GetHashCode">
            <summary> Returns the hash code of the collection.</summary>
            <remarks> Returns the hash code of the collection. Collection members
            get activated as required.</remarks>
            <seealso cref="!:System.Collections.Generic.IDictionary"/>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="P:Db4objects.Db4o.Collections.ArrayDictionary4`2.Count">
            <summary> Returns the number of elements in the collection.</summary>
            <remarks> Returns the number of elements in the collection. The collection gets activated. </remarks>
            <seealso cref="!:System.Collections.Generic.IDictionary"/>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="P:Db4objects.Db4o.Collections.ArrayDictionary4`2.Values">
            <summary> Returns the values of the collection.</summary>
            <remarks> Returns the values of the collection. The collection gets activated.</remarks>
            <seealso cref="!:System.Collections.Generic.IDictionary"/>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="T:Db4objects.Db4o.Collections.ArrayList4`1">
            <summary>Transparent activatable ArrayList implementation.
            </summary>
            <remarks>
            Transparent activatable ArrayList implementation. Implements IList
            interface using an array to store elements. Each ArrayList4 instance
            has a capacity, which indicates the size of the internal array.
            <br/>
            <br/>
            When instantiated as a result of a query, all the internal members
            are NOT activated at all. When internal members are required to
            perform an operation, the instance transparently activates all the
            members.
            </remarks>
            <seealso cref="T:System.Collections.ArrayList">System.Collections.ArrayList
            </seealso>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.Activate(Db4objects.Db4o.Activation.ActivationPurpose)">
            <summary>activate basic implementation.</summary>
            <remarks>activate basic implementation.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.Bind(Db4objects.Db4o.Activation.IActivator)">
            <summary>bind basic implementation.</summary>
            <remarks>bind basic implementation.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.#ctor">
            <summary>
            Initializes a new collection with the initial capacity = 10.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.#ctor(System.Collections.Generic.ICollection{`0})">
            <summary>
            Initializes a collection with the members of the parameter collection.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.#ctor(System.Int32)">
            <summary>
            Initializes a collection of the specified initial capacity.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.Add(System.Int32,`0)">
            <summary> Inserts an element into the collection
            at the specified index. </summary>
            <remarks> Inserts an element into the collection
            at the specified index.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.Clear">
            <summary> Removes all elements from the collection.</summary>
            <remarks> Removes all elements from the collection.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.EnsureCapacity(System.Int32)">
            <summary> Resizes the collection capacity to the specified size if the
            current capacity is less than the parameter value.</summary>
            <remarks> Resizes the collection capacity to the specified size if the
            current capacity is less than the parameter value.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.Get(System.Int32)">
            <summary> Returns the collection element at the specified index.</summary>
            <remarks> Returns the collection element at the specified index.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.RemoveImpl(System.Int32)">
            <summary> Removes the collection element at the specified index.</summary>
            <remarks> Removes the collection element at the specified index.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.Set(System.Int32,`0)">
            <summary> Replaces the collection element with the specified object at the specified index.</summary>
            <remarks> Replaces the collection element with the specified object at the specified index.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Collections.ArrayList4`1.TrimExcess">
            <summary> Resizes the collection to its actual size.</summary>
            <remarks> Resizes the collection to its actual size.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="P:Db4objects.Db4o.Collections.ArrayList4`1.Count">
            <summary> Returns the size of the collection.</summary>
            <remarks> Returns the size of the collection.</remarks>
            <seealso cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable
            </seealso>
        </member>
        <member name="T:Db4objects.Db4o.Collections.CollectionFactory">
            <summary>
            Collection factory with methods to create collections with behaviour
            that is optimized for db4o.<br/><br/>
            Example usage:<br/>
            <code>CollectionFactory.forObjectContainer(objectContainer).newBigSet();</code>
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Collections.CollectionFactory.ForObjectContainer(Db4objects.Db4o.IObjectContainer)">
            <summary>returns a collection factory for an ObjectContainer</summary>
            <param name="objectContainer">- the ObjectContainer</param>
            <returns>the CollectionFactory</returns>
        </member>
        <member name="M:Db4objects.Db4o.Collections.CollectionFactory.NewBigSet``1">
            <summary>
            creates a new BigSet.<br/><br/>
            Characteristics of BigSet:<br/>
            - It is optimized by using a BTree of IDs of persistent objects.<br/>
            - It can only hold persistent first class objects (no primitives, no strings, no objects that are not persistent)<br/>
            - Objects are activated upon getting them from the BigSet.
            </summary>
            <remarks>
            creates a new BigSet.<br/><br/>
            Characteristics of BigSet:<br/>
            - It is optimized by using a BTree of IDs of persistent objects.<br/>
            - It can only hold persistent first class objects (no primitives, no strings, no objects that are not persistent)<br/>
            - Objects are activated upon getting them from the BigSet.
            <br/><br/>
            BigSet is recommend whenever one object references a huge number of other objects and sorting is not required.
            </remarks>
            <returns></returns>
        </member>
        <member name="T:Db4objects.Db4o.Config.ConfigScope">
            <summary>
            Defines a scope of applicability of a config setting.<br/><br/>
            Some of the configuration settings can be either: <br/><br/>
            - enabled globally; <br/>
            - enabled individually for a specified class; <br/>
            - disabled.<br/><br/>
            </summary>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.GenerateUUIDs(Db4objects.Db4o.Config.ConfigScope)">IConfiguration.GenerateUUIDs(ConfigScope)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.GenerateVersionNumbers(Db4objects.Db4o.Config.ConfigScope)">IConfiguration.GenerateVersionNumbers(ConfigScope)
            	</seealso>
        </member>
        <member name="F:Db4objects.Db4o.Config.ConfigScope.Disabled">
            <summary>Marks a configuration feature as globally disabled.</summary>
            <remarks>Marks a configuration feature as globally disabled.</remarks>
        </member>
        <member name="F:Db4objects.Db4o.Config.ConfigScope.Individually">
            <summary>Marks a configuration feature as individually configurable.</summary>
            <remarks>Marks a configuration feature as individually configurable.</remarks>
        </member>
        <member name="F:Db4objects.Db4o.Config.ConfigScope.Globally">
            <summary>Marks a configuration feature as globally enabled.</summary>
            <remarks>Marks a configuration feature as globally enabled.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.ConfigScope.ApplyConfig(Db4objects.Db4o.Foundation.TernaryBool)">
            <summary>
            Checks if the current configuration scope is globally
            enabled or disabled.
            </summary>
            <remarks>
            Checks if the current configuration scope is globally
            enabled or disabled.
            </remarks>
            <param name="defaultValue">- default result</param>
            <returns>
            false if disabled, true if globally enabled, default
            value otherwise
            </returns>
        </member>
        <member name="T:Db4objects.Db4o.Config.Encoding.IStringEncoding">
            <summary>
            encodes a String to a byte array and decodes a String
            from a part of a byte array
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Config.Encoding.IStringEncoding.Encode(System.String)">
            <summary>called when a string is to be encoded to a byte array.</summary>
            <remarks>called when a string is to be encoded to a byte array.</remarks>
            <param name="str">the string to encode</param>
            <returns>the encoded byte array</returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.Encoding.IStringEncoding.Decode(System.Byte[],System.Int32,System.Int32)">
            <summary>called when a byte array is to be decoded to a string.</summary>
            <remarks>called when a byte array is to be decoded to a string.</remarks>
            <param name="bytes">the byte array</param>
            <param name="start">the start offset in the byte array</param>
            <param name="length">the length of the encoded string in the byte array</param>
            <returns>the string</returns>
        </member>
        <member name="T:Db4objects.Db4o.Config.Encoding.StringEncodings">
            <summary>All built in String encodings</summary>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.StringEncoding(Db4objects.Db4o.Config.Encoding.IStringEncoding)">Db4objects.Db4o.Config.IConfiguration.StringEncoding(IStringEncoding)</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Config.Entry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Config.ICompare">
            <summary>allows special comparison behaviour during query evaluation.</summary>
            <remarks>
            allows special comparison behaviour during query evaluation.
            <br/><br/>db4o will use the Object returned by the
            <see cref="M:Db4objects.Db4o.Config.ICompare.Compare">Compare()</see>
            method for all query comparisons.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICompare.Compare">
            <summary>return the Object to be compared during query evaluation.</summary>
            <remarks>return the Object to be compared during query evaluation.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.IInternal4">
            <summary>Marker interface to denote that a class is used for db4o internals.</summary>
            <remarks>Marker interface to denote that a class is used for db4o internals.</remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Config.GlobalOnlyConfigException">
            <summary>
            db4o-specific exception.<br/><br/>
            This exception is thrown when a global configuration
            setting is attempted on an open object container.
            </summary>
            <remarks>
            db4o-specific exception.<br/><br/>
            This exception is thrown when a global configuration
            setting is attempted on an open object container.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.BlockSize(System.Int32)">IConfiguration.BlockSize(int)</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)">IConfiguration.Encrypt(bool)</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Io(Db4objects.Db4o.IO.IoAdapter)">IConfiguration.Io(Db4objects.Db4o.IO.IoAdapter)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">IConfiguration.Password(string)</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Db4oException">
            <summary>
            db4o exception wrapper: Exceptions occurring during internal processing
            will be proliferated to the client calling code encapsulated in an exception
            of this type.
            </summary>
            <remarks>
            db4o exception wrapper: Exceptions occurring during internal processing
            will be proliferated to the client calling code encapsulated in an exception
            of this type. The original exception, if any, is available through
            Db4oException#getCause().
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oException.#ctor">
            <summary>Simple constructor</summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oException.#ctor(System.String)">
            <summary>Constructor with an exception message specified</summary>
            <param name="msg">exception message</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oException.#ctor(System.Exception)">
            <summary>Constructor with an exception cause specified</summary>
            <param name="cause">exception cause</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oException.#ctor(System.Int32)">
            <summary>
            Constructor with an exception message selected
            from the internal message collection.
            </summary>
            <remarks>
            Constructor with an exception message selected
            from the internal message collection.
            </remarks>
            <param name="messageConstant">internal db4o message number</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oException.#ctor(System.String,System.Exception)">
            <summary>Constructor with an exception message and cause specified</summary>
            <param name="msg">exception message</param>
            <param name="cause">exception cause</param>
        </member>
        <member name="T:Db4objects.Db4o.Config.IAlias">
            <summary>
            Implement this interface when implementing special custom Aliases
            for classes, packages or namespaces.
            
            </summary>
            <remarks>
            Implement this interface when implementing special custom Aliases
            for classes, packages or namespaces.
            <br/><br/>Aliases can be used to persist classes in the running
            application to different persistent classes in a database file
            or on a db4o server.
            <br/><br/>Two simple Alias implementations are supplied along with
            db4o:<br/>
            -
            <see cref="T:Db4objects.Db4o.Config.TypeAlias">TypeAlias</see>
            provides an #equals() resolver to match
            names directly.<br/>
            -
            <see cref="T:Db4objects.Db4o.Config.WildcardAlias">WildcardAlias</see>
            allows simple pattern matching
            with one single '*' wildcard character.<br/>
            <br/>
            It is possible to create
            own complex
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            constructs by creating own resolvers
            that implement the
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            interface.
            <br/><br/>
            Examples of concrete usecases:
            <br/><br/>
            <code>
            <b>// Creating an Alias for a single class</b><br/>
            ICommonConfiguration.AddAlias(<br/>
              new TypeAlias("Tutorial.Pilot", "Tutorial.Driver"));<br/>
            <br/><br/>
            <b>// Accessing a Java package from a .NET assembly </b><br/>
            ICommonConfiguration.AddAlias(<br/>
              new WildcardAlias(<br/>
                "com.f1.*",<br/>
                "Tutorial.F1.*, Tutorial"));<br/>
            <br/><br/>
            <b>// Using a different local .NET assembly</b><br/>
            ICommonConfiguration.AddAlias(<br/>
              new WildcardAlias(<br/>
                "Tutorial.F1.*, F1Race",<br/>
                "Tutorial.F1.*, Tutorial"));<br/>
            <br/><br/>
            </code>
            <br/><br/>Aliases that translate the persistent name of a class to
            a name that already exists as a persistent name in the database
            (or on the server) are not permitted and will throw an exception
            when the database file is opened.
            <br/><br/>Aliases should be configured before opening a database file
            or connecting to a server.
            
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IAlias.ResolveRuntimeName(System.String)">
            <summary>return the stored name for a runtime name or null if not handled.</summary>
            <remarks>return the stored name for a runtime name or null if not handled.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IAlias.ResolveStoredName(System.String)">
            <summary>return the runtime name for a stored name or null if not handled.</summary>
            <remarks>return the runtime name for a stored name or null if not handled.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Config.ICacheConfiguration">
            <summary>Interface to configure the cache configurations.</summary>
            <remarks>Interface to configure the cache configurations.</remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICacheConfiguration.SlotCacheSize">
            <summary>
            configures the size of the slot cache to hold a number of
            slots in the cache.
            </summary>
            <remarks>
            configures the size of the slot cache to hold a number of
            slots in the cache.
            </remarks>
            <value>the number of slots</value>
        </member>
        <member name="T:Db4objects.Db4o.Config.ICacheConfigurationProvider">
            <summary>
            A configuration provider that provides access
            to the cache-related configuration methods.
            </summary>
            <remarks>
            A configuration provider that provides access
            to the cache-related configuration methods.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICacheConfigurationProvider.Cache">
            <summary>Access to the cache-related configuration methods.</summary>
            <remarks>Access to the cache-related configuration methods.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Config.IClientServerConfiguration">
            <summary>Client/Server configuration interface.</summary>
            <remarks>Client/Server configuration interface.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.PrefetchIDCount(System.Int32)">
            <summary>
            Sets the number of IDs to be pre-allocated in the database for new
            objects created on the client.
            </summary>
            <remarks>
            Sets the number of IDs to be pre-allocated in the database for new
            objects created on the client.
            This setting should be used on the client side. In embedded mode this setting
            has no effect.
            </remarks>
            <param name="prefetchIDCount">The number of IDs to be prefetched</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.PrefetchObjectCount(System.Int32)">
            <summary>Sets the number of objects to be prefetched for an ObjectSet.</summary>
            <remarks>
            Sets the number of objects to be prefetched for an ObjectSet.
            This setting should be used on the server side.
            </remarks>
            <param name="prefetchObjectCount">The number of objects to be prefetched</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.PrefetchDepth(System.Int32)">
            <summary>Sets the depth to which prefetched objects are activated.</summary>
            <remarks>
            Sets the depth to which prefetched objects are activated.
            This setting should be used on the client side.
            </remarks>
            <param name="prefetchDepth"></param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.PrefetchSlotCacheSize(System.Int32)">
            <summary>Sets the slot cache size to the given value.</summary>
            <remarks>Sets the slot cache size to the given value.</remarks>
            <param name="slotCacheSize"></param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.SetMessageRecipient(Db4objects.Db4o.Messaging.IMessageRecipient)">
            <summary>sets the MessageRecipient to receive Client Server messages.</summary>
            <remarks>
            sets the MessageRecipient to receive Client Server messages. <br />
            <br />
            This setting should be used on the server side.<br /><br />
            </remarks>
            <param name="messageRecipient">the MessageRecipient to be used</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.GetMessageSender">
            <summary>returns the MessageSender for this Configuration context.</summary>
            <remarks>
            returns the MessageSender for this Configuration context.
            This setting should be used on the client side.
            </remarks>
            <returns>MessageSender</returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.TimeoutClientSocket(System.Int32)">
            <summary>
            configures the time a client waits for a message response
            from the server.
            </summary>
            <remarks>
            configures the time a client waits for a message response
            from the server. <br/>
            <br/>
            Default value: 600000ms (10 minutes)<br/>
            <br/>
            It is recommended to use the same values for
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.TimeoutClientSocket(System.Int32)">TimeoutClientSocket(int)</see>
            and
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.TimeoutServerSocket(System.Int32)">TimeoutServerSocket(int)</see>
            .
            <br/>
            This setting can be used on both client and server.<br/><br/>
            </remarks>
            <param name="milliseconds">time in milliseconds</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.TimeoutServerSocket(System.Int32)">
            <summary>configures the timeout of the serverside socket.</summary>
            <remarks>
            configures the timeout of the serverside socket. <br/>
            <br/>
            The serverside handler waits for messages to arrive from the client.
            If no more messages arrive for the duration configured in this
            setting, the client will be disconnected.
            <br/>
            Clients send PING messages to the server at an interval of
            Math.min(timeoutClientSocket(), timeoutServerSocket()) / 2
            and the server will respond to keep connections alive.
            <br/>
            Decrease this setting if you want clients to disconnect faster.
            <br/>
            Increase this setting if you have a large number of clients and long
            running queries and you are getting disconnected clients that you
            would like to wait even longer for a response from the server.
            <br/>
            Default value: 600000ms (10 minutes)<br/>
            <br/>
            It is recommended to use the same values for
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.TimeoutClientSocket(System.Int32)">TimeoutClientSocket(int)</see>
            and
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.TimeoutServerSocket(System.Int32)">TimeoutServerSocket(int)</see>
            .
            <br/>
            This setting can be used on both client and server.<br/><br/>
            </remarks>
            <param name="milliseconds">time in milliseconds</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.SingleThreadedClient(System.Boolean)">
            <summary>
            configures the client messaging system to be single threaded
            or multithreaded.
            </summary>
            <remarks>
            configures the client messaging system to be single threaded
            or multithreaded.
            <br /><br />Recommended settings:<br />
            - <code>true</code> for low resource systems.<br />
            - <code>false</code> for best asynchronous performance and fast
            GUI response.
            <br /><br />Default value:<br />
            - .NET Compactframework: <code>true</code><br />
            - all other platforms: <code>false</code><br /><br />
            This setting can be used on both client and server.<br /><br />
            </remarks>
            <param name="flag">the desired setting</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.BatchMessages(System.Boolean)">
            <summary>Configures to batch messages between client and server.</summary>
            <remarks>
            Configures to batch messages between client and server. By default, batch
            mode is enabled.<br /><br />
            This setting can be used on both client and server.<br /><br />
            </remarks>
            <param name="flag">false, to turn message batching off.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IClientServerConfiguration.MaxBatchQueueSize(System.Int32)">
            <summary>Configures the maximum memory buffer size for batched message.</summary>
            <remarks>
            Configures the maximum memory buffer size for batched message. If the
            size of batched messages is greater than <code>maxSize</code>, batched
            messages will be sent to server.<br /><br />
            This setting can be used on both client and server.<br /><br />
            </remarks>
            <param name="maxSize"></param>
        </member>
        <member name="T:Db4objects.Db4o.Config.ICommonConfiguration">
            <summary>
            Common configuration methods, applicable for
            embedded, client and server use of db4o.<br /><br />
            In Client/Server use it is good practice to configure the
            client and the server in exactly the same way.
            </summary>
            <remarks>
            Common configuration methods, applicable for
            embedded, client and server use of db4o.<br /><br />
            In Client/Server use it is good practice to configure the
            client and the server in exactly the same way.
            </remarks>
            <since>7.5</since>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.AddAlias(Db4objects.Db4o.Config.IAlias)">
            <summary>adds a new Alias for a class, namespace or package.</summary>
            <remarks>
            adds a new Alias for a class, namespace or package.
            <br/><br/>Aliases can be used to persist classes in the running
            application to different persistent classes in a database file
            or on a db4o server.
            <br/><br/>Two simple Alias implementations are supplied along with
            db4o:<br/>
            -
            <see cref="T:Db4objects.Db4o.Config.TypeAlias">TypeAlias</see>
            provides an #equals() resolver to match
            names directly.<br/>
            -
            <see cref="T:Db4objects.Db4o.Config.WildcardAlias">WildcardAlias</see>
            allows simple pattern matching
            with one single '*' wildcard character.<br/>
            <br/>
            It is possible to create
            own complex
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            constructs by creating own resolvers
            that implement the
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            interface.
            <br/><br/>
            Examples of concrete usecases:
            <br/><br/>
            <code>
            <b>// Creating an Alias for a single class</b><br/>
            Db4o.configure().addAlias(<br/>
              new TypeAlias("com.f1.Pilot", "com.f1.Driver"));<br/>
            <br/><br/>
            <b>// Accessing a .NET assembly from a Java package</b><br/>
            Db4o.configure().addAlias(<br/>
              new WildcardAlias(<br/>
                "Tutorial.F1.*, Tutorial",<br/>
                "com.f1.*"));<br/>
            <br/><br/>
            <b>// Mapping a Java package onto another</b><br/>
            Db4o.configure().addAlias(<br/>
              new WildcardAlias(<br/>
                "com.f1.*",<br/>
                "com.f1.client*"));<br/></code>
            <br/><br/>Aliases that translate the persistent name of a class to
            a name that already exists as a persistent name in the database
            (or on the server) are not permitted and will throw an exception
            when the database file is opened.
            <br/><br/>Aliases should be configured before opening a database file
            or connecting to a server.<br/><br/>
            In client/server environment this setting should be used on the client
            and on the server side.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.RemoveAlias(Db4objects.Db4o.Config.IAlias)">
            <summary>
            Removes an alias previously added with
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AddAlias(Db4objects.Db4o.Config.IAlias)">IConfiguration.AddAlias(IAlias)</see>
            .
            </summary>
            <param name="alias">the alias to remove</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.Add(Db4objects.Db4o.Config.IConfigurationItem)">
            <summary>
            adds ConfigurationItems to be applied when
            an ObjectContainer or ObjectServer is opened.
            </summary>
            <remarks>
            adds ConfigurationItems to be applied when
            an ObjectContainer or ObjectServer is opened.
            </remarks>
            <param name="configurationItem">the ConfigurationItem</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.MarkTransient(System.String)">
            <summary>allows to mark fields as transient with custom attributes.</summary>
            <remarks>
            allows to mark fields as transient with custom attributes.
            <br /><br />.NET only: Call this method with the attribute name that you
            wish to use to mark fields as transient. Multiple transient attributes
            are possible by calling this method multiple times with different
            attribute names.<br /><br />
            In client/server environment the setting should be used on both
            client and server.<br /><br />
            </remarks>
            <param name="attributeName">
            - the fully qualified name of the attribute, including
            it's namespace
            TODO: can we provide meaningful java side semantics for this one?
            TODO: USE A CLASS!!!!!!
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.ObjectClass(System.Object)">
            <summary>
            returns an
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">IObjectClass</see>
            object
            to configure the specified class.
            <br/><br/>
            The clazz parameter can be any of the following:<br/>
            - a fully qualified classname as a String.<br/>
            - a Class object.<br/>
            - any other object to be used as a template.<br/><br/>
            </summary>
            <param name="clazz">class name, Class object, or example object.<br/><br/></param>
            <returns>
            an instance of an
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">IObjectClass</see>
            object for configuration.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.ReflectWith(Db4objects.Db4o.Reflect.IReflector)">
            <summary>configures the use of a specially designed reflection implementation.</summary>
            <remarks>
            configures the use of a specially designed reflection implementation.
            <br /><br />
            db4o internally uses java.lang.reflect.* by default. On platforms that
            do not support this package, customized implementations may be written
            to supply all the functionality of the interfaces in the com.db4o.reflect
            package. This method can be used to install a custom reflection
            implementation.<br /><br />
            In client-server environment this setting should be used on both the client and
            the server side (reflector class must be available)<br /><br />
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.RegisterTypeHandler(Db4objects.Db4o.Typehandlers.ITypeHandlerPredicate,Db4objects.Db4o.Typehandlers.ITypeHandler4)">
            <summary>
            allows registering special TypeHandlers for customized marshalling
            and customized comparisons.
            </summary>
            <remarks>
            allows registering special TypeHandlers for customized marshalling
            and customized comparisons.
            </remarks>
            <param name="predicate">
            to specify for which classes and versions the
            TypeHandler is to be used.
            </param>
            <param name="typeHandler">to be used for the classes that match the predicate.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.ICommonConfiguration.NameProvider(Db4objects.Db4o.Config.INameProvider)">
            <summary>
            Registers a
            <see cref="T:Db4objects.Db4o.Config.INameProvider">INameProvider</see>
            that assigns a custom name to the database to be used in
            <see cref="M:System.Object.ToString">object.ToString()</see>
            .
            </summary>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.ActivationDepth">
            <summary>sets the activation depth to the specified value.</summary>
            <remarks>
            sets the activation depth to the specified value.
            <br/><br/><b>Why activation?</b><br/>
            When objects are instantiated from the database, the instantiation of member
            objects needs to be limited to a certain depth. Otherwise a single object
            could lead to loading the complete database into memory, if all objects where
            reachable from a single root object.<br/><br/>
            db4o uses the concept "depth", the number of field-to-field hops an object
            is away from another object. <b>The preconfigured "activation depth" db4o uses
            in the default setting is 5.</b>
            <br/><br/>Whenever an application iterates through the
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            of a query result, the result objects
            will be activated to the configured activation depth.<br/><br/>
            A concrete example with the preconfigured activation depth of 5:<br/>
            <pre>
            // Object foo is the result of a query, it is delivered by the ObjectSet
            object foo = objectSet.Next();</pre>
            foo.member1.member2.member3.member4.member5 will be a valid object<br/>
            foo, member1, member2, member3 and member4 will be activated<br/>
            member5 will be deactivated, all of it's members will be null<br/>
            member5 can be activated at any time by calling
            <see cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">IObjectContainer.Activate(member5, depth)
            </see>
            .
            <br/><br/>
            Note that raising the global activation depth will consume more memory and
            have negative effects on the performance of first-time retrievals. Lowering
            the global activation depth needs more individual activation work but can
            increase performance of queries.<br/><br/>
            <see cref="M:Db4objects.Db4o.IObjectContainer.Deactivate(System.Object,System.Int32)">IObjectContainer.Deactivate(object, depth)
            </see>
            can be used to manually free memory by deactivating objects.<br/><br/>
            In client/server environment the same setting should be used on both
            client and server<br/><br/>.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">configuring classes individually
            </seealso>
            <summary>gets the configured activation depth.</summary>
            <summary>sets the activation depth to the specified value.</summary>
            <remarks>
            sets the activation depth to the specified value.
            <br/><br/><b>Why activation?</b><br/>
            When objects are instantiated from the database, the instantiation of member
            objects needs to be limited to a certain depth. Otherwise a single object
            could lead to loading the complete database into memory, if all objects where
            reachable from a single root object.<br/><br/>
            db4o uses the concept "depth", the number of field-to-field hops an object
            is away from another object. <b>The preconfigured "activation depth" db4o uses
            in the default setting is 5.</b>
            <br/><br/>Whenever an application iterates through the
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            of a query result, the result objects
            will be activated to the configured activation depth.<br/><br/>
            A concrete example with the preconfigured activation depth of 5:<br/>
            <pre>
            // Object foo is the result of a query, it is delivered by the ObjectSet
            object foo = objectSet.Next();</pre>
            foo.member1.member2.member3.member4.member5 will be a valid object<br/>
            foo, member1, member2, member3 and member4 will be activated<br/>
            member5 will be deactivated, all of it's members will be null<br/>
            member5 can be activated at any time by calling
            <see cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">IObjectContainer.Activate(member5, depth)
            </see>
            .
            <br/><br/>
            Note that raising the global activation depth will consume more memory and
            have negative effects on the performance of first-time retrievals. Lowering
            the global activation depth needs more individual activation work but can
            increase performance of queries.<br/><br/>
            <see cref="M:Db4objects.Db4o.IObjectContainer.Deactivate(System.Object,System.Int32)">IObjectContainer.Deactivate(object, depth)
            </see>
            can be used to manually free memory by deactivating objects.<br/><br/>
            In client/server environment the same setting should be used on both
            client and server<br/><br/>.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">configuring classes individually
            </seealso>
            <summary>gets the configured activation depth.</summary>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.AllowVersionUpdates">
            <summary>turns automatic database file format version updates on.</summary>
            <remarks>
            turns automatic database file format version updates on.
            <br /><br />Upon db4o database file format version changes,
            db4o can automatically update database files to the
            current version. db4objects does not provide functionality
            to reverse this process. It is not ensured that updated
            database files can be read with older db4o versions.
            In some cases (Example: using ObjectManager) it may not be
            desirable to update database files automatically therefore
            automatic updating is turned off by default for
            security reasons.
            <br /><br />Call this method to turn automatic database file
            version updating on.
            <br /><br />If automatic updating is turned off, db4o will refuse
            to open database files that use an older database file format.<br /><br />
            In client-server environment this setting should be used on both client
            and server.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.AutomaticShutDown">
            <summary>turns automatic shutdown of the engine on and off.</summary>
            <remarks>
            turns automatic shutdown of the engine on and off.
            The default and recommended setting is <code>true</code>.<br/><br/>
            In client-server environment this setting should be used on both client
            and server.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.BTreeNodeSize">
            <summary>configures the size of BTree nodes in indexes.</summary>
            <remarks>
            configures the size of BTree nodes in indexes.
            <br /><br />Default setting: 100
            <br />Lower values will allow a lower memory footprint
            and more efficient reading and writing of small slots.
            <br />Higher values will reduce the overall number of
            read and write operations and allow better performance
            at the cost of more RAM use.<br /><br />
            This setting should be used on both client and server in
            client-server environment.
            </remarks>
            <value>the number of elements held in one BTree node.</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.Callbacks">
            <summary>turns callback methods on and off.</summary>
            <remarks>
            turns callback methods on and off.
            <br/><br/>Callbacks are turned on by default.<br/><br/>
            A tuning hint: If callbacks are not used, you can turn this feature off, to
            prevent db4o from looking for callback methods in persistent classes. This will
            increase the performance on system startup.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.
            </remarks>
            <value>false to turn callback methods off</value>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.CallConstructors">
            <summary>
            advises db4o to try instantiating objects with/without calling
            constructors.
            </summary>
            <remarks>
            advises db4o to try instantiating objects with/without calling
            constructors.
            <br/><br/>
            Not all .NET-environments support this feature. db4o will
            attempt, to follow the setting as good as the enviroment supports.
            This setting may also be overridden for individual classes in
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.CallConstructor(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CallConstructor
            </see>
            .
            <br/><br/>The default setting depends on the features supported by your current environment.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.
            <br/><br/>
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CallConstructor(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CallConstructor
            </seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.DetectSchemaChanges">
            <summary>
            tuning feature: configures whether db4o checks all persistent classes upon system
            startup, for added or removed fields.
            </summary>
            <remarks>
            tuning feature: configures whether db4o checks all persistent classes upon system
            startup, for added or removed fields.
            <br /><br />If this configuration setting is set to false while a database is
            being created, members of classes will not be detected and stored.
            <br /><br />This setting can be set to false in a production environment after
            all persistent classes have been stored at least once and classes will not
            be modified any further in the future.<br /><br />
            In a client/server environment this setting should be configured both on the
            client and and on the server.
            <br /><br />Default value:<br />
            <code>true</code>
            </remarks>
            <value>the desired setting</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.Diagnostic">
            <summary>returns the configuration interface for diagnostics.</summary>
            <remarks>returns the configuration interface for diagnostics.</remarks>
            <returns>the configuration interface for diagnostics.</returns>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.ExceptionsOnNotStorable">
            <summary>configures whether Exceptions are to be thrown, if objects can not be stored.
            	</summary>
            <remarks>
            configures whether Exceptions are to be thrown, if objects can not be stored.
            <br/><br/>db4o requires the presence of a constructor that can be used to
            instantiate objects. If no default public constructor is present, all
            available constructors are tested, whether an instance of the class can
            be instantiated. Null is passed to all constructor parameters.
            The first constructor that is successfully tested will
            be used throughout the running db4o session. If an instance of the class
            can not be instantiated, the object will not be stored. By default,
            execution will be stopped with an Exception. This method can
            be used to configure db4o to not throw an
            <see cref="T:Db4objects.Db4o.Ext.ObjectNotStorableException">ObjectNotStorableException
            	</see>
            if an object can not be stored.
            <br/><br/>
            The default for this setting is <b>true</b>.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.<br/><br/>
            </remarks>
            <value>true to throw Exceptions if objects can not be stored.</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.InternStrings">
            <summary>configures db4o to call Intern() on strings upon retrieval.</summary>
            <remarks>
            configures db4o to call Intern on strings upon retrieval if set to true.
            In client/server environment the setting should be used on both
            client and server.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.MessageLevel">
            <summary>sets the detail level of db4o messages.</summary>
            <remarks>
            sets the detail level of db4o messages. Messages will be output to the
            configured output
            <see cref="T:System.IO.TextWriter">TextWriter</see>
            .
            <br/><br/>
            Level 0 - no messages<br/>
            Level 1 - open and close messages<br/>
            Level 2 - messages for new, update and delete<br/>
            Level 3 - messages for activate and deactivate<br/><br/>
            When using client-server and the level is set to 0, the server will override this and set it to 1.  To get around this you can set the level to -1.  This has the effect of not returning any messages.<br/><br/>
            In client-server environment this setting can be used on client or on server
            depending on which information do you want to track (server side provides more
            detailed information).<br/><br/>
            </remarks>
            <value>integer from 0 to 3</value>
            <seealso cref="!:OutStream(System.IO.TextWriter)">TODO: replace int with enumeration
            	</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries">
            <summary>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            </summary>
            <remarks>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            The following assemblies should be available for native query switch to take effect:
            Db4objects.Db4o.NativeQueries.dll, Db4objects.Db4o.Instrumentation.dll.
            <br/><br/>The default setting is <code>true</code>.<br/><br/>
            In client-server environment this setting should be used on both client and server.<br/><br/>
            </remarks>
            <seealso cref="P:Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries">Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries</seealso>
            <summary>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            </summary>
            <remarks>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            The following assemblies should be available for native query switch to take effect:
            Db4objects.Db4o.NativeQueries.dll, Db4objects.Db4o.Instrumentation.dll.
            <br/><br/>The default setting is <code>true</code>.<br/><br/>
            In client-server environment this setting should be used on both client and server.<br/><br/>
            </remarks>
            <seealso cref="P:Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries">Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.Queries">
            <summary>returns the Query configuration interface.</summary>
            <remarks>returns the Query configuration interface.</remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.OutStream">
            <summary>
            Assigns a
            <see cref="T:System.IO.TextWriter">TextWriter</see>
            where db4o is to print its event messages.
            <br/><br/>Messages are useful for debugging purposes and for learning
            to understand, how db4o works. The message level can be raised with
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.MessageLevel(System.Int32)">IConfiguration.MessageLevel(int)</see>
            to produce more detailed messages.
            <br/><br/>Use <code>outStream(System.out)</code> to print messages to the
            console.<br/><br/>
            In client-server environment this setting should be used on the same side
            where
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.MessageLevel(System.Int32)">IConfiguration.MessageLevel(int)</see>
            is used.<br/><br/>
            </summary>
            <value>the new <code>PrintStream</code> for messages.</value>
            <seealso cref="!:MessageLevel(int)">MessageLevel(int)</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.StringEncoding">
            <summary>configures the string encoding to be used.</summary>
            <remarks>
            configures the string encoding to be used.
            <br/><br/>The string encoding can not be changed in the lifetime of a
            database file. To set up the database with the correct string encoding,
            this configuration needs to be set correctly <b>before</b> a database
            file is created with the first call to
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile
            </see>
            or
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">Db4objects.Db4o.Db4oFactory.OpenServer
            </see>
            .
            <br/><br/>For subsequent open calls, db4o remembers built-in
            string encodings. If a custom encoding is used (an encoding that is
            not supplied from within the db4o library), the correct encoding
            needs to be configured correctly again for all subsequent calls
            that open database files.
            <br/><br/>Example:<br/>
            <code>config.StringEncoding = StringEncodings.Utf8();</code>
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Config.Encoding.StringEncodings">Db4objects.Db4o.Config.Encoding.StringEncodings
            </seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.TestConstructors">
            <summary>
            tuning feature: configures whether db4o should try to instantiate one instance
            of each persistent class on system startup.
            </summary>
            <remarks>
            tuning feature: configures whether db4o should try to instantiate one instance
            of each persistent class on system startup.
            <br /><br />In a production environment this setting can be set to <code>false</code>,
            if all persistent classes have public default constructors.
            <br /><br />
            In client-server environment this setting should be used on both client and server
            side. <br /><br />
            Default value:<br />
            <code>true</code>
            </remarks>
            <value>the desired setting</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.UpdateDepth">
            <summary>specifies the global updateDepth.</summary>
            <remarks>
            specifies the global updateDepth.
            <br/><br/>see the documentation of
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)"></see>
            for further details.<br/><br/>
            The value be may be overridden for individual classes.<br/><br/>
            The default setting is 1: Only the object passed to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</see>
            will be updated.<br/><br/>
            In client-server environment this setting should be used on both client and
            server sides.<br/><br/>
            </remarks>
            <value>the depth of the desired update.</value>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">IObjectClass.UpdateDepth(int)</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">IObjectClass.CascadeOnUpdate(bool)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.WeakReferences">
            <summary>turns weak reference management on or off.</summary>
            <remarks>
            turns weak reference management on or off.
            <br/><br/>
            This method must be called before opening a database.
            <br/><br/>
            Performance may be improved by running db4o without using weak
            references durring memory management at the cost of higher
            memory consumption or by alternatively implementing a manual
            memory management scheme using
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Purge(System.Object)">Db4objects.Db4o.Ext.IExtObjectContainer.Purge(object)
            	</see>
            <br/><br/>Setting the value to <code>false</code> causes db4o to use hard
            references to objects, preventing the garbage collection process
            from disposing of unused objects.
            <br/><br/>The default setting is <code>true</code>.
            <br/><br/>Ignored on JDKs before 1.2.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.WeakReferenceCollectionInterval">
            <summary>configures the timer for WeakReference collection.</summary>
            <remarks>
            configures the timer for WeakReference collection.
            <br /><br />The default setting is 1000 milliseconds.
            <br /><br />Configure this setting to zero to turn WeakReference
            collection off.
            <br /><br />Ignored on JDKs before 1.2.<br /><br />
            </remarks>
            <value>the time in milliseconds</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfiguration.Environment">
            <seealso cref="T:Db4objects.Db4o.Foundation.IEnvironment">Db4objects.Db4o.Foundation.IEnvironment
            	</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Config.ICommonConfigurationProvider">
            <summary>
            A configuration provider that provides access to
            the common configuration methods that can be called
            for embedded, server and client use of db4o.
            </summary>
            <remarks>
            A configuration provider that provides access to
            the common configuration methods that can be called
            for embedded, server and client use of db4o.
            </remarks>
            <since>7.5</since>
        </member>
        <member name="P:Db4objects.Db4o.Config.ICommonConfigurationProvider.Common">
            <summary>Access to the common configuration methods.</summary>
            <remarks>Access to the common configuration methods.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Config.IConfiguration">
            <summary>configuration interface.</summary>
            <remarks>
            configuration interface.
            <br/><br/>This interface contains methods to configure db4o.<br/><br/>
            The global Configuration context is available with
            <see cref="M:Db4objects.Db4o.Db4oFactory.Configure">Db4objects.Db4o.Db4oFactory.Configure()
            	</see>
            .
            When an ObjectContainer or ObjectServer is opened, the global Configuration
            context is cloned and copied into the ObjectContainer/ObjectServer.
            That means every ObjectContainer/ObjectServer gets it's own copy of
            configuration settings.<br/><br/>
            <b>Most configuration settings should be set before opening an
            ObjectContainer/ObjectServer</b>.
            <br/><br/>Some configuration settings can be modified on an open
            ObjectContainer/ObjectServer. The local Configuration context is
            available with
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Configure">Db4objects.Db4o.Ext.IExtObjectContainer.Configure()
            	</see>
            and
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectServer.Configure">Db4objects.Db4o.Ext.IExtObjectServer.Configure()
            	</see>
            .
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">
            <summary>sets the activation depth to the specified value.</summary>
            <remarks>
            sets the activation depth to the specified value.
            <br/><br/><b>Why activation?</b><br/>
            When objects are instantiated from the database, the instantiation of member
            objects needs to be limited to a certain depth. Otherwise a single object
            could lead to loading the complete database into memory, if all objects where
            reachable from a single root object.<br/><br/>
            db4o uses the concept "depth", the number of field-to-field hops an object
            is away from another object. <b>The preconfigured "activation depth" db4o uses
            in the default setting is 5.</b>
            <br/><br/>Whenever an application iterates through the
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            of a query result, the result objects
            will be activated to the configured activation depth.<br/><br/>
            A concrete example with the preconfigured activation depth of 5:<br/>
            <pre>
            // Object foo is the result of a query, it is delivered by the ObjectSet
            object foo = objectSet.Next();</pre>
            foo.member1.member2.member3.member4.member5 will be a valid object<br/>
            foo, member1, member2, member3 and member4 will be activated<br/>
            member5 will be deactivated, all of it's members will be null<br/>
            member5 can be activated at any time by calling
            <see cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">IObjectContainer.Activate(member5, depth)
            </see>
            .
            <br/><br/>
            Note that raising the global activation depth will consume more memory and
            have negative effects on the performance of first-time retrievals. Lowering
            the global activation depth needs more individual activation work but can
            increase performance of queries.<br/><br/>
            <see cref="M:Db4objects.Db4o.IObjectContainer.Deactivate(System.Object,System.Int32)">IObjectContainer.Deactivate(object, depth)
            </see>
            can be used to manually free memory by deactivating objects.<br/><br/>
            In client/server environment the same setting should be used on both
            client and server<br/><br/>.
            </remarks>
            <param name="depth">the desired global activation depth.</param>
            
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">configuring classes individually
            </seealso>
            
            <summary>gets the configured activation depth.</summary>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">
            <summary>gets the configured activation depth.</summary>
            <remarks>gets the configured activation depth.</remarks>
            <returns>the configured activation depth.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Add(Db4objects.Db4o.Config.IConfigurationItem)">
            <summary>
            adds ConfigurationItems to be applied when
            an ObjectContainer or ObjectServer is opened.
            </summary>
            <remarks>
            adds ConfigurationItems to be applied when
            an ObjectContainer or ObjectServer is opened.
            </remarks>
            <param name="configurationItem">the ConfigurationItem</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.AddAlias(Db4objects.Db4o.Config.IAlias)">
            <summary>adds a new Alias for a class, namespace or package.
            </summary>
            <remarks>
            adds a new Alias for a class, namespace or package.
            <br/>
            <br/>
            Aliases can be used to persist classes in the running application
            to different persistent classes in a database file or on a db4o
            server.
            <br/>
            <br/>
            Two simple Alias implementations are supplied along with db4o:
            <br/>
            -
            <see cref="T:Db4objects.Db4o.Config.TypeAlias">TypeAlias</see>
            provides an #equals() resolver to match names directly.
            <br/>
            -
            <see cref="T:Db4objects.Db4o.Config.WildcardAlias">WildcardAlias</see>
            allows simple pattern matching with one single '*' wildcard
            character.
            <br/>
            <br/>
            It is possible to create own complex
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            constructs by creating own resolvers that implement the
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            interface.
            <br/>
            <br/>
            Four examples of concrete usecases:
            <br/>
            <br/>
            <code>
            <b>// Creating an Alias for a single class</b>
            <br/>
            Db4oFactory.Configure().AddAlias(
            <br/>  new TypeAlias("Tutorial.F1.Pilot", "Tutorial.F1.Driver"));<br/>
            <br/><br/>
            <b>// Accessing a Java package from a .NET assembly</b><br/>
            Db4o.configure().addAlias(<br/>
              new WildcardAlias(<br/>
                "com.f1.*",<br/>
                "Tutorial.F1.*, Tutorial"));<br/>
            <br/><br/>
            <b>// Using a different local .NET assembly</b><br/>
            Db4o.configure().addAlias(<br/>
              new WildcardAlias(<br/>
                "Tutorial.F1.*, Tutorial",<br/>
                "Tutorial.F1.*, RaceClient"));<br/>
            </code>
            <br/><br/>Aliases that translate the persistent name of a class to
            a name that already exists as a persistent name in the database
            (or on the server) are not permitted and will throw an exception
            when the database file is opened.
            <br/><br/>Aliases should be configured before opening a database file
            or connecting to a server.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.RemoveAlias(Db4objects.Db4o.Config.IAlias)">
            <summary>
            Removes an alias previously added with
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AddAlias(Db4objects.Db4o.Config.IAlias)">AddAlias(IAlias)</see>
            .
            </summary>
            <param name="alias">the alias to remove</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            <summary>turns automatic database file format version updates on.</summary>
            <remarks>
            turns automatic database file format version updates on.
            <br /><br />Upon db4o database file format version changes,
            db4o can automatically update database files to the
            current version. db4objects does not provide functionality
            to reverse this process. It is not ensured that updated
            database files can be read with older db4o versions.
            In some cases (Example: using ObjectManager) it may not be
            desirable to update database files automatically therefore
            automatic updating is turned off by default for
            security reasons.
            <br /><br />Call this method to turn automatic database file
            version updating on.
            <br /><br />If automatic updating is turned off, db4o will refuse
            to open database files that use an older database file format.<br /><br />
            In client-server environment this setting should be used on both client
            and server.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.AutomaticShutDown(System.Boolean)">
            <summary>turns automatic shutdown of the engine on and off.</summary>
            <remarks>
            turns automatic shutdown of the engine on and off.
            </remarks>
            <param name="flag">whether db4o should shut down automatically.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.BlockSize(System.Int32)">
            <summary>sets the storage data blocksize for new ObjectContainers.</summary>
            <remarks>
            sets the storage data blocksize for new ObjectContainers.
            <br/><br/>The standard setting is 1 allowing for a maximum
            database file size of 2GB. This value can be increased
            to allow larger database files, although some space will
            be lost to padding because the size of some stored objects
            will not be an exact multiple of the block size. A
            recommended setting for large database files is 8, since
            internal pointers have this length.<br/><br/>
            This setting is only effective when the database is first created, in
            client-server environment in most cases it means that the setting
            should be used on the server side.
            </remarks>
            <param name="bytes">the size in bytes from 1 to 127</param>
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.BTreeNodeSize(System.Int32)">
            <summary>configures the size of BTree nodes in indexes.</summary>
            <remarks>
            configures the size of BTree nodes in indexes.
            <br /><br />Default setting: 100
            <br />Lower values will allow a lower memory footprint
            and more efficient reading and writing of small slots.
            <br />Higher values will reduce the overall number of
            read and write operations and allow better performance
            at the cost of more RAM use.<br /><br />
            This setting should be used on both client and server in
            client-server environment.
            </remarks>
            <param name="size">the number of elements held in one BTree node.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.BTreeCacheHeight(System.Int32)">
            <summary>configures caching of BTree nodes.</summary>
            <remarks>
            configures caching of BTree nodes.
            <br /><br />Clean BTree nodes will be unloaded on #commit and
            #rollback unless they are configured as cached here.
            <br /><br />Default setting: 0
            <br />Possible settings: 1, 2 or 3
            <br /><br /> The potential number of cached BTree nodes can be
            calculated with the following forumula:<br />
            maxCachedNodes = bTreeNodeSize ^ bTreeCacheHeight<br /><br />
            This setting should be used on both client and server in
            client-server environment.
            </remarks>
            <param name="height">the height of the cache from the root</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Cache">
            <summary>returns the Cache configuration interface.</summary>
            <remarks>returns the Cache configuration interface.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Callbacks(System.Boolean)">
            <summary>turns callback methods on and off.</summary>
            <remarks>
            turns callback methods on and off.
            <br/><br/>Callbacks are turned on by default.<br/><br/>
            A tuning hint: If callbacks are not used, you can turn this feature off, to
            prevent db4o from looking for callback methods in persistent classes. This will
            increase the performance on system startup.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.
            </remarks>
            <param name="flag">false to turn callback methods off</param>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.CallConstructors(System.Boolean)">
            <summary>
            advises db4o to try instantiating objects with/without calling
            constructors.
            </summary>
            <remarks>
            advises db4o to try instantiating objects with/without calling
            constructors.
            <br/><br/>
            Not all .NET-environments support this feature. db4o will
            attempt, to follow the setting as good as the enviroment supports.
            This setting may also be overridden for individual classes in
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.CallConstructor(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CallConstructor
            </see>
            .
            <br/><br/>The default setting depends on the features supported by your current environment.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.
            <br/><br/>
            </remarks>
            <param name="flag">
            - specify true, to request calling constructors, specify
            false to request <b>not</b> calling constructors.
            </param>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CallConstructor(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CallConstructor
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ClassActivationDepthConfigurable(System.Boolean)">
            <summary>
            turns
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">individual class activation depth configuration
            	</see>
            on
            and off.
            <br/><br/>This feature is turned on by default.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.<br/><br/>
            </summary>
            <param name="flag">
            false to turn the possibility to individually configure class
            activation depths off
            </param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ClientServer">
            <summary>returns client/server configuration interface.</summary>
            <remarks>returns client/server configuration interface.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.DatabaseGrowthSize(System.Int32)">
            <summary>
            configures the size database files should grow in bytes, when no
            free slot is found within.
            </summary>
            <remarks>
            configures the size database files should grow in bytes, when no
            free slot is found within.
            <br /><br />Tuning setting.
            <br /><br />Whenever no free slot of sufficient length can be found
            within the current database file, the database file's length
            is extended. This configuration setting configures by how much
            it should be extended, in bytes.<br /><br />
            This configuration setting is intended to reduce fragmentation.
            Higher values will produce bigger database files and less
            fragmentation.<br /><br />
            To extend the database file, a single byte array is created
            and written to the end of the file in one write operation. Be
            aware that a high setting will require allocating memory for
            this byte array.
            </remarks>
            <param name="bytes">amount of bytes</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.DetectSchemaChanges(System.Boolean)">
            <summary>
            tuning feature: configures whether db4o checks all persistent classes upon system
            startup, for added or removed fields.
            </summary>
            <remarks>
            tuning feature: configures whether db4o checks all persistent classes upon system
            startup, for added or removed fields.
            <br /><br />If this configuration setting is set to false while a database is
            being created, members of classes will not be detected and stored.
            <br /><br />This setting can be set to false in a production environment after
            all persistent classes have been stored at least once and classes will not
            be modified any further in the future.<br /><br />
            In a client/server environment this setting should be configured both on the
            client and and on the server.
            <br /><br />Default value:<br />
            <code>true</code>
            </remarks>
            <param name="flag">the desired setting</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Diagnostic">
            <summary>returns the configuration interface for diagnostics.</summary>
            <remarks>returns the configuration interface for diagnostics.</remarks>
            <returns>the configuration interface for diagnostics.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.DisableCommitRecovery">
            <summary>turns commit recovery off.</summary>
            <remarks>
            turns commit recovery off.
            <br /><br />db4o uses a two-phase commit algorithm. In a first step all intended
            changes are written to a free place in the database file, the "transaction commit
            record". In a second step the
            actual changes are performed. If the system breaks down during commit, the
            commit process is restarted when the database file is opened the next time.
            On very rare occasions (possibilities: hardware failure or editing the database
            file with an external tool) the transaction commit record may be broken. In this
            case, this method can be used to try to open the database file without commit
            recovery. The method should only be used in emergency situations after consulting
            db4o support.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.DiscardFreeSpace(System.Int32)">
            <summary>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            </summary>
            <remarks>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            <br /><br />When objects are updated or deleted, the space previously occupied in the
            database file is marked as "free", so it can be reused. db4o maintains two lists
            in RAM, sorted by address and by size. Adjacent entries are merged. After a large
            number of updates or deletes have been executed, the lists can become large, causing
            RAM consumption and performance loss for maintenance. With this method you can
            specify an upper bound for the byte slot size to discard.
            <br /><br />Pass <code>Integer.MAX_VALUE</code> to this method to discard all free slots for
            the best possible startup time.<br /><br />
            The downside of setting this value: Database files will necessarily grow faster.
            <br /><br />Default value:<br />
            <code>0</code> all space is reused
            </remarks>
            <param name="byteCount">Slots with this size or smaller will be lost.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)">
            <summary>configures the use of encryption.</summary>
            <remarks>
            configures the use of encryption.
            <br/><br/>This method needs to be called <b>before</b> a database file
            is created with the first
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile(string)
            	</see>
            .
            <br/><br/>If encryption is set to true,
            you need to supply a password to seed the encryption mechanism.<br/><br/>
            db4o database files keep their encryption format after creation.<br/><br/>
            </remarks>
            <param name="flag">
            true for turning encryption on, false for turning encryption
            off.
            </param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">Password(string)</seealso>
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ExceptionsOnNotStorable(System.Boolean)">
            <summary>configures whether Exceptions are to be thrown, if objects can not be stored.
            	</summary>
            <remarks>
            configures whether Exceptions are to be thrown, if objects can not be stored.
            <br/><br/>db4o requires the presence of a constructor that can be used to
            instantiate objects. If no default public constructor is present, all
            available constructors are tested, whether an instance of the class can
            be instantiated. Null is passed to all constructor parameters.
            The first constructor that is successfully tested will
            be used throughout the running db4o session. If an instance of the class
            can not be instantiated, the object will not be stored. By default,
            execution will continue without any message or error. This method can
            be used to configure db4o to throw an
            <see cref="T:Db4objects.Db4o.Ext.ObjectNotStorableException">ObjectNotStorableException
            	</see>
            if an object can not be stored.
            <br/><br/>
            The default for this setting is <b>true</b>.<br/><br/>
            In client/server environment this setting should be used on both
            client and server.<br/><br/>
            </remarks>
            <param name="flag">false to not throw Exceptions if objects can not be stored (fail silently).
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.FlushFileBuffers(System.Boolean)">
            <summary>configuration setting to turn file buffer flushing off.</summary>
            <remarks>
            configuration setting to turn file buffer flushing off.
            <br/><br/>
            This configuration setting is no longer in use.
            To tune db4o performance at the cost of a higher risc of database
            file corruption in case of abnormal session terminations, please
            use a
            <see cref="T:Db4objects.Db4o.IO.NonFlushingStorage">Db4objects.Db4o.IO.NonFlushingStorage
            	</see>
            .
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Freespace">
            <summary>returns the freespace configuration interface.</summary>
            <remarks>returns the freespace configuration interface.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.GenerateUUIDs(System.Int32)">
            <summary>configures db4o to generate UUIDs for stored objects.</summary>
            <remarks>configures db4o to generate UUIDs for stored objects.</remarks>
            <param name="setting">
            one of the following values:<br />
            -1 - off<br />
            1 - configure classes individually<br />
            Integer.MAX_Value - on for all classes<br /><br />
            This setting should be used when the database is first created.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.GenerateUUIDs(Db4objects.Db4o.Config.ConfigScope)">
            <summary>configures db4o to generate UUIDs for stored objects.</summary>
            <remarks>
            configures db4o to generate UUIDs for stored objects.
            This setting should be used when the database is first created.<br /><br />
            </remarks>
            <param name="setting">the scope for UUID generation: disabled, generate for all classes, or configure individually
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.GenerateVersionNumbers(System.Int32)">
            <summary>configures db4o to generate version numbers for stored objects.</summary>
            <remarks>configures db4o to generate version numbers for stored objects.</remarks>
            <param name="setting">
            one of the following values:<br />
            -1 - off<br />
            1 - configure classes individually<br />
            Integer.MAX_Value - on for all classes<br /><br />
            This setting should be used when the database is first created.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.GenerateVersionNumbers(Db4objects.Db4o.Config.ConfigScope)">
            <summary>configures db4o to generate version numbers for stored objects.</summary>
            <remarks>
            configures db4o to generate version numbers for stored objects.
            This setting should be used when the database is first created.
            </remarks>
            <param name="setting">the scope for version number generation: disabled, generate for all classes, or configure individually
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.InternStrings(System.Boolean)">
            <summary>configures db4o to call #intern() on strings upon retrieval.</summary>
            <remarks>
            configures db4o to call #intern() on strings upon retrieval.
            In client/server environment the setting should be used on both
            client and server.
            </remarks>
            <param name="flag">true to intern strings</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.InternStrings">
            <summary>returns true if strings will be interned.</summary>
            <remarks>returns true if strings will be interned.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Io(Db4objects.Db4o.IO.IoAdapter)">
            <summary>allows to configure db4o to use a customized byte IO adapter.</summary>
            <remarks>
            allows to configure db4o to use a customized byte IO adapter.
            <br/><br/>Derive from the abstract class
            <see cref="T:Db4objects.Db4o.IO.IoAdapter">Db4objects.Db4o.IO.IoAdapter</see>
            to
            write your own. Possible usecases could be improved performance
            with a native library, mirrored write to two files, encryption or
            read-on-write fail-safety control.<br/><br/>An example of a custom
            io adapter can be found in xtea_db4o community project:<br/>
            http://developer.db4o.com/ProjectSpaces/view.aspx/XTEA<br/><br/>
            In client-server environment this setting should be used on the server
            (adapter class must be available)<br/><br/>
            </remarks>
            <param name="adapter">- the IoAdapter</param>
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Io">
            <summary>
            returns the configured
            <see cref="T:Db4objects.Db4o.IO.IoAdapter">Db4objects.Db4o.IO.IoAdapter</see>
            .
            </summary>
            <returns></returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.MarkTransient(System.String)">
            <summary>allows to mark fields as transient with custom attributes.</summary>
            <remarks>
            allows to mark fields as transient with custom attributes.
            <br /><br />.NET only: Call this method with the attribute name that you
            wish to use to mark fields as transient. Multiple transient attributes
            are possible by calling this method multiple times with different
            attribute names.<br /><br />
            In client/server environment the setting should be used on both
            client and server.<br /><br />
            </remarks>
            <param name="attributeName">
            - the fully qualified name of the attribute, including
            it's namespace
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.MessageLevel(System.Int32)">
            <summary>sets the detail level of db4o messages.</summary>
            <remarks>
            sets the detail level of db4o messages. Messages will be output to the
            configured output
            <see cref="T:System.IO.TextWriter">TextWriter</see>
            .
            <br/><br/>
            Level 0 - no messages<br/>
            Level 1 - open and close messages<br/>
            Level 2 - messages for new, update and delete<br/>
            Level 3 - messages for activate and deactivate<br/><br/>
            When using client-server and the level is set to 0, the server will override this and set it to 1.  To get around this you can set the level to -1.  This has the effect of not returning any messages.<br/><br/>
            In client-server environment this setting can be used on client or on server
            depending on which information do you want to track (server side provides more
            detailed information).<br/><br/>
            </remarks>
            <param name="level">integer from 0 to 3</param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.SetOut(System.IO.TextWriter)">SetOut(System.IO.TextWriter)</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.LockDatabaseFile(System.Boolean)">
            <summary>can be used to turn the database file locking thread off.</summary>
            <param name="flag">
            <code>false</code> to turn database file locking off.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ObjectClass(System.Object)">
            <summary>
            returns an
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">IObjectClass</see>
            object
            to configure the specified class.
            <br/><br/>
            The clazz parameter can be any of the following:<br/>
            - a fully qualified classname as a String.<br/>
            - a Class object.<br/>
            - any other object to be used as a template.<br/><br/>
            </summary>
            <param name="clazz">class name, Class object, or example object.<br/><br/></param>
            <returns>
            an instance of an
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">IObjectClass</see>
            object for configuration.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.OptimizeNativeQueries(System.Boolean)">
            <summary>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            </summary>
            <remarks>
            If set to true, db4o will try to optimize native queries
            dynamically at query execution time, otherwise it will
            run native queries in unoptimized mode as SODA evaluations.
            The following assemblies should be available for native query switch to take effect:
            Db4objects.Db4o.NativeQueries.dll, Db4objects.Db4o.Instrumentation.dll.
            <br/><br/>The default setting is <code>true</code>.<br/><br/>
            In client-server environment this setting should be used on both client and server.<br/><br/>
            </remarks>
            <param name="optimizeNQ">
            true, if db4o should try to optimize
            native queries at query execution time, false otherwise
            </param>
            
            <seealso cref="P:Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries">Db4objects.Db4o.Config.ICommonConfiguration.OptimizeNativeQueries</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.OptimizeNativeQueries">
            <summary>indicates whether Native Queries will be optimized dynamically.</summary>
            <remarks>indicates whether Native Queries will be optimized dynamically.</remarks>
            <returns>
            boolean true if Native Queries will be optimized
            dynamically.
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.OptimizeNativeQueries">OptimizeNativeQueries()</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">
            <summary>protects the database file with a password.</summary>
            <remarks>
            protects the database file with a password.
            <br/><br/>To set a password for a database file, this method needs to be
            called <b>before</b> a database file is created with the first
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile(string)
            	</see>
            .
            <br/><br/>All further attempts to open
            the file, are required to set the same password.<br/><br/>The password
            is used to seed the encryption mechanism, which makes it impossible
            to read the database file without knowing the password.<br/><br/>
            </remarks>
            <param name="pass">the password to be used.</param>
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Queries">
            <summary>returns the Query configuration interface.</summary>
            <remarks>returns the Query configuration interface.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)">
            <summary>turns readOnly mode on and off.</summary>
            <remarks>
            turns readOnly mode on and off.
            <br/><br/>This method configures the mode in which subsequent calls to
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4o.openFile()</see>
            will open files.
            <br/><br/>Readonly mode allows to open an unlimited number of reading
            processes on one database file. It is also convenient
            for deploying db4o database files on CD-ROM.<br/><br/>
            In client-server environment this setting should be used on the server side
            in embedded mode and ONLY on client side in networked mode.<br/><br/>
            </remarks>
            <param name="flag">
            <code>true</code> for configuring readOnly mode for subsequent
            calls to
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4o.openFile()</see>
            .
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.RecoveryMode(System.Boolean)">
            <summary>
            turns recovery mode on and off.<br /><br />
            Recovery mode can be used to try to retrieve as much as possible
            out of an already corrupted database.
            </summary>
            <remarks>
            turns recovery mode on and off.<br /><br />
            Recovery mode can be used to try to retrieve as much as possible
            out of an already corrupted database. In recovery mode internal
            checks are more relaxed. Null or invalid objects may be returned
            instead of throwing exceptions.<br /><br />
            Use this method with care as a last resort to get data out of a
            corrupted database.
            </remarks>
            <param name="flag"><code>true</code> to turn recover mode on.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ReflectWith(Db4objects.Db4o.Reflect.IReflector)">
            <summary>configures the use of a specially designed reflection implementation.</summary>
            <remarks>
            configures the use of a specially designed reflection implementation.
            <br/><br/>
            db4o internally uses System.Reflection by default. On platforms that
            do not support this package, customized implementations may be written
            to supply all the functionality of the interfaces in System.Reflection
            namespace. This method can be used to install a custom reflection
            implementation.
            
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.RefreshClasses">
            <summary>This method is no longer supported and will be removed.</summary>
            <remarks>This method is no longer supported and will be removed.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.ReserveStorageSpace(System.Int64)">
            <summary>tuning feature only: reserves a number of bytes in database files.</summary>
            <remarks>
            tuning feature only: reserves a number of bytes in database files.
            <br/><br/>The global setting is used for the creation of new database
            files. Continous calls on an ObjectContainer Configuration context
            (see
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Configure">Db4objects.Db4o.Ext.IExtObjectContainer.Configure()
            	</see>
            ) will
            continually allocate space.
            <br/><br/>The allocation of a fixed number of bytes at one time
            makes it more likely that the database will be stored in one
            chunk on the mass storage. Less read/write head movement can result
            in improved performance.<br/><br/>
            <b>Note:</b><br/> Allocated space will be lost on abnormal termination
            of the database engine (hardware crash, VM crash). A Defragment run
            will recover the lost space. For the best possible performance, this
            method should be called before the Defragment run to configure the
            allocation of storage space to be slightly greater than the anticipated
            database file size.
            <br/><br/>
            In client-server environment this setting should be used on the server side. <br/><br/>
            Default configuration: 0<br/><br/>
            </remarks>
            <param name="byteCount">the number of bytes to reserve</param>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.SetBlobPath(System.String)">
            <summary>
            configures the path to be used to store and read
            Blob data.
            </summary>
            <remarks>
            configures the path to be used to store and read
            Blob data.
            <br/><br/>
            In client-server environment this setting should be used on the
            server side. <br/><br/>
            </remarks>
            <param name="path">the path to be used</param>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.SetClassLoader(System.Object)">
            <summary>configures db4o to use a custom ClassLoader.</summary>
            <remarks>
            configures db4o to use a custom ClassLoader.
            <br /><br />
            </remarks>
            <param name="classLoader">the ClassLoader to be used</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.SetOut(System.IO.TextWriter)">
            <summary>
            Assigns a
            <see cref="T:System.IO.TextWriter">TextWriter</see>
            where db4o is to print its event messages.
            <br/><br/>Messages are useful for debugging purposes and for learning
            to understand, how db4o works. The message level can be raised with
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.MessageLevel(System.Int32)">MessageLevel(int)</see>
            to produce more detailed messages.
            <br/><br/>Use <code>setOut(System.out)</code> to print messages to the
            console.<br/><br/>
            In client-server environment this setting should be used on the same side
            where
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.MessageLevel(System.Int32)">MessageLevel(int)</see>
            is used.<br/><br/>
            </summary>
            <param name="outStream">the new <code>PrintStream</code> for messages.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.MessageLevel(System.Int32)">MessageLevel(int)</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.StringEncoding(Db4objects.Db4o.Config.Encoding.IStringEncoding)">
            <summary>configures the string encoding to be used.</summary>
            <remarks>
            configures the string encoding to be used.
            <br/><br/>The string encoding can not be changed in the lifetime of a
            database file. To set up the database with the correct string encoding,
            this configuration needs to be set correctly <b>before</b> a database
            file is created with the first call to
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile
            </see>
            or
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">Db4objects.Db4o.Db4oFactory.OpenServer
            </see>
            .
            <br/><br/>For subsequent open calls, db4o remembers built-in
            string encodings. If a custom encoding is used (an encoding that is
            not supplied from within the db4o library), the correct encoding
            needs to be configured correctly again for all subsequent calls
            that open database files.
            <br/><br/>Example:<br/>
            <code>config.StringEncoding(StringEncodings.Utf8());</code>
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Config.Encoding.StringEncodings">Db4objects.Db4o.Config.Encoding.StringEncodings
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.TestConstructors(System.Boolean)">
            <summary>
            tuning feature: configures whether db4o should try to instantiate one instance
            of each persistent class on system startup.
            </summary>
            <remarks>
            tuning feature: configures whether db4o should try to instantiate one instance
            of each persistent class on system startup.
            <br /><br />In a production environment this setting can be set to <code>false</code>,
            if all persistent classes have public default constructors.
            <br /><br />
            In client-server environment this setting should be used on both client and server
            side. <br /><br />
            Default value:<br />
            <code>true</code>
            </remarks>
            <param name="flag">the desired setting</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.Unicode(System.Boolean)">
            <summary>configures the storage format of Strings.</summary>
            <remarks>
            configures the storage format of Strings.
            <br/><br/>This method needs to be called <b>before</b> a database file
            is created with the first
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile(string)
            	</see>
            or
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">Db4objects.Db4o.Db4oFactory.OpenServer(string, int)
            	</see>
            .
            db4o database files keep their string format after creation.<br/><br/>
            Turning Unicode support off reduces the file storage space for strings
            by factor 2 and improves performance.<br/><br/>
            Default setting: <b>true</b><br/><br/>
            </remarks>
            <param name="flag">
            <code>true</code> for turning Unicode support on, <code>false</code> for turning
            Unicode support off.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.UpdateDepth(System.Int32)">
            <summary>specifies the global updateDepth.</summary>
            <remarks>
            specifies the global updateDepth.
            <br/><br/>see the documentation of
            <see cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)"></see>
            for further details.<br/><br/>
            The value be may be overridden for individual classes.<br/><br/>
            The default setting is 1: Only the object passed to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">Db4objects.Db4o.IObjectContainer.Set(object)
            	</see>
            will be updated.<br/><br/>
            In client-server environment this setting should be used on both client and
            server sides.<br/><br/>
            </remarks>
            <param name="depth">the depth of the desired update.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">IObjectClass.UpdateDepth(int)</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">IObjectClass.CascadeOnUpdate(bool)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.WeakReferences(System.Boolean)">
            <summary>turns weak reference management on or off.</summary>
            <remarks>
            turns weak reference management on or off.
            <br/><br/>
            This method must be called before opening a database.
            <br/><br/>
            Performance may be improved by running db4o without using weak
            references durring memory management at the cost of higher
            memory consumption or by alternatively implementing a manual
            memory management scheme using
            <see cref="!:IExtObjectContainer.Purge">IExtObjectContainer.Purge</see>
            <br/><br/>Setting the value to <code>false</code> causes db4o to use hard
            references to objects, preventing the garbage collection process
            from disposing of unused objects.
            <br/><br/>The default setting is <code>true</code>.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.WeakReferenceCollectionInterval(System.Int32)">
            <summary>configures the timer for WeakReference collection.</summary>
            <remarks>
            configures the timer for WeakReference collection.
            <br/><br/>The default setting is 1000 milliseconds.
            <br/><br/>Configure this setting to zero to turn WeakReference
            collection off.
            
            </remarks>
            <param name="milliseconds">the time in milliseconds</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfiguration.RegisterTypeHandler(Db4objects.Db4o.Typehandlers.ITypeHandlerPredicate,Db4objects.Db4o.Typehandlers.ITypeHandler4)">
            <summary>
            allows registering special TypeHandlers for customized marshalling
            and customized comparisons.
            </summary>
            <remarks>
            allows registering special TypeHandlers for customized marshalling
            and customized comparisons.
            </remarks>
            <param name="predicate">
            to specify for which classes and versions the
            TypeHandler is to be used.
            </param>
            <param name="typeHandler">to be used for the classes that match the predicate.</param>
        </member>
        <member name="P:Db4objects.Db4o.Config.IConfiguration.Storage">
            <summary>allows to configure db4o to use a customized byte IO storage mechanism.</summary>
            <remarks>
            allows to configure db4o to use a customized byte IO storage mechanism.
            <br/><br/>Implement the interface
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            to
            write your own. Possible usecases could be improved performance
            with a native library, mirrored write to two files, encryption or
            read-on-write fail-safety control.<br/><br/>
            </remarks>
            <value>- the factory</value>
            <seealso cref="T:Db4objects.Db4o.IO.CachingStorage">Db4objects.Db4o.IO.CachingStorage
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.IO.MemoryStorage">Db4objects.Db4o.IO.MemoryStorage
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.IO.FileStorage">Db4objects.Db4o.IO.FileStorage</seealso>
            <seealso cref="T:Db4objects.Db4o.IO.StorageDecorator">Db4objects.Db4o.IO.StorageDecorator
            	</seealso>
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
            <summary>
            returns the configured
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Config.IConfigurationItem">
            <summary>
            Implement this interface for configuration items that encapsulate
            a batch of configuration settings or that need to be applied
            to ObjectContainers after they are opened.
            </summary>
            <remarks>
            Implement this interface for configuration items that encapsulate
            a batch of configuration settings or that need to be applied
            to ObjectContainers after they are opened.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfigurationItem.Prepare(Db4objects.Db4o.Config.IConfiguration)">
            <summary>Gives a chance for the item to augment the configuration.</summary>
            <remarks>Gives a chance for the item to augment the configuration.</remarks>
            <param name="configuration">the configuration that the item was added to</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IConfigurationItem.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)">
            <summary>Gives a chance for the item to configure the just opened ObjectContainer.
            	</summary>
            <remarks>Gives a chance for the item to configure the just opened ObjectContainer.
            	</remarks>
            <param name="container">the ObjectContainer to configure</param>
        </member>
        <member name="T:Db4objects.Db4o.Config.IEmbeddedConfiguration">
            <summary>Configuration interface for db4o in embedded use.</summary>
            <remarks>Configuration interface for db4o in embedded use.</remarks>
            <since>7.5</since>
        </member>
        <member name="T:Db4objects.Db4o.Config.IFileConfigurationProvider">
            <summary>
            A configuration provider that provides access
            to the file-related configuration methods.
            </summary>
            <remarks>
            A configuration provider that provides access
            to the file-related configuration methods.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfigurationProvider.File">
            <summary>Access to the file-related configuration methods.</summary>
            <remarks>Access to the file-related configuration methods.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IEmbeddedConfiguration.AddConfigurationItem(Db4objects.Db4o.Config.IEmbeddedConfigurationItem)">
            <summary>
            adds ConfigurationItems to be applied when
            a networking
            <see cref="!:EmbeddedObjectContainer">EmbeddedObjectContainer</see>
            is opened.
            </summary>
            <param name="configItem">
            the
            <see cref="T:Db4objects.Db4o.Config.IEmbeddedConfigurationItem">IEmbeddedConfigurationItem</see>
            </param>
            <since>7.12</since>
        </member>
        <member name="T:Db4objects.Db4o.Config.IEmbeddedConfigurationItem">
            <summary>
            Implement this interface for configuration items that encapsulate
            a batch of configuration settings or that need to be applied
            to EmbeddedObjectContainers after they are opened.
            </summary>
            <remarks>
            Implement this interface for configuration items that encapsulate
            a batch of configuration settings or that need to be applied
            to EmbeddedObjectContainers after they are opened.
            </remarks>
            <since>7.12</since>
        </member>
        <member name="M:Db4objects.Db4o.Config.IEmbeddedConfigurationItem.Prepare(Db4objects.Db4o.Config.IEmbeddedConfiguration)">
            <summary>Gives a chance for the item to augment the configuration.</summary>
            <remarks>Gives a chance for the item to augment the configuration.</remarks>
            <param name="configuration">the configuration that the item was added to</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IEmbeddedConfigurationItem.Apply(Db4objects.Db4o.IEmbeddedObjectContainer)">
            <summary>Gives a chance for the item to configure the just opened ObjectContainer.
            	</summary>
            <remarks>Gives a chance for the item to configure the just opened ObjectContainer.
            	</remarks>
            <param name="container">the ObjectContainer to configure</param>
        </member>
        <member name="T:Db4objects.Db4o.Config.IEnvironmentConfiguration">
            <summary>Configures the environment (set of services) used by db4o.</summary>
            <remarks>Configures the environment (set of services) used by db4o.</remarks>
            <seealso cref="T:Db4objects.Db4o.Foundation.IEnvironment">Db4objects.Db4o.Foundation.IEnvironment
            	</seealso>
            <seealso cref="!:Db4objects.Db4o.Foundation.Environments.My(System.Type&lt;T&gt;)">Db4objects.Db4o.Foundation.Environments.My(System.Type&lt;T&gt;)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IEnvironmentConfiguration.Add(System.Object)">
            <summary>Contributes a service to the db4o environment.</summary>
            <remarks>Contributes a service to the db4o environment.</remarks>
            <param name="service"></param>
        </member>
        <member name="T:Db4objects.Db4o.Config.IFileConfiguration">
            <summary>
            File-related configuration methods, applicable
            for db4o embedded use and on the server in a
            Client/Server setup.
            </summary>
            <remarks>
            File-related configuration methods, applicable
            for db4o embedded use and on the server in a
            Client/Server setup.
            </remarks>
            <since>7.5</since>
            <seealso cref="P:Db4objects.Db4o.Config.IFileConfigurationProvider.File">IFileConfigurationProvider.File()
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFileConfiguration.DisableCommitRecovery">
            <summary>turns commit recovery off.</summary>
            <remarks>
            turns commit recovery off.
            <br /><br />db4o uses a two-phase commit algorithm. In a first step all intended
            changes are written to a free place in the database file, the "transaction commit
            record". In a second step the
            actual changes are performed. If the system breaks down during commit, the
            commit process is restarted when the database file is opened the next time.
            On very rare occasions (possibilities: hardware failure or editing the database
            file with an external tool) the transaction commit record may be broken. In this
            case, this method can be used to try to open the database file without commit
            recovery. The method should only be used in emergency situations after consulting
            db4o support.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.BlockSize">
            <summary>sets the storage data blocksize for new ObjectContainers.</summary>
            <remarks>
            sets the storage data blocksize for new ObjectContainers.
            <br /><br />The standard setting is 1 allowing for a maximum
            database file size of 2GB. This value can be increased
            to allow larger database files, although some space will
            be lost to padding because the size of some stored objects
            will not be an exact multiple of the block size. A
            recommended setting for large database files is 8, since
            internal pointers have this length.<br /><br />
            This setting is only effective when the database is first created, in
            client-server environment in most cases it means that the setting
            should be used on the server side.
            </remarks>
            <value>the size in bytes from 1 to 127</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.DatabaseGrowthSize">
            <summary>
            configures the size database files should grow in bytes, when no
            free slot is found within.
            </summary>
            <remarks>
            configures the size database files should grow in bytes, when no
            free slot is found within.
            <br /><br />Tuning setting.
            <br /><br />Whenever no free slot of sufficient length can be found
            within the current database file, the database file's length
            is extended. This configuration setting configures by how much
            it should be extended, in bytes.<br /><br />
            This configuration setting is intended to reduce fragmentation.
            Higher values will produce bigger database files and less
            fragmentation.<br /><br />
            To extend the database file, a single byte array is created
            and written to the end of the file in one write operation. Be
            aware that a high setting will require allocating memory for
            this byte array.
            </remarks>
            <value>amount of bytes</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.Freespace">
            <summary>returns the freespace configuration interface.</summary>
            <remarks>returns the freespace configuration interface.</remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.GenerateUUIDs">
            <summary>configures db4o to generate UUIDs for stored objects.</summary>
            <remarks>
            configures db4o to generate UUIDs for stored objects.
            This setting should be used when the database is first created.<br /><br />
            </remarks>
            <value>the scope for UUID generation: disabled, generate for all classes, or configure individually
            	</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.GenerateVersionNumbers">
            <summary>configures db4o to generate version numbers for stored objects.</summary>
            <remarks>
            configures db4o to generate version numbers for stored objects.
            This setting should be used when the database is first created.
            </remarks>
            <value>the scope for version number generation: disabled, generate for all classes, or configure individually
            	</value>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.Storage">
            <summary>allows to configure db4o to use a customized byte IO storage mechanism.</summary>
            <remarks>
            allows to configure db4o to use a customized byte IO storage mechanism.
            <br/><br/>You can implement the interface
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            to
            write your own. Possible usecases could be improved performance
            with a native library, mirrored write to two files, encryption or
            read-on-write fail-safety control.<br/><br/>
            </remarks>
            <value>- the storage</value>
            <seealso cref="T:Db4objects.Db4o.IO.FileStorage">Db4objects.Db4o.IO.FileStorage</seealso>
            <seealso cref="T:Db4objects.Db4o.IO.CachingStorage">Db4objects.Db4o.IO.CachingStorage
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.IO.MemoryStorage">Db4objects.Db4o.IO.MemoryStorage
            	</seealso>
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
            <summary>
            returns the configured
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            .
            </summary>
            <returns></returns>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.LockDatabaseFile">
            <summary>can be used to turn the database file locking thread off.</summary>
            <remarks>
            can be used to turn the database file locking thread off.
            <br/><br/><b>Caution!</b><br/>If database file
            locking is turned off, concurrent write access to the same
            database file from different sessions will <b>corrupt</b> the
            database file immediately.<br/><br/> This method
            has no effect on open ObjectContainers. It will only affect how
            ObjectContainers are opened.<br/><br/>
            The default setting is <code>true</code>.<br/><br/>
            In client-server environment this setting should be used on both client and server.<br/><br/>
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.ReserveStorageSpace">
            <summary>tuning feature only: reserves a number of bytes in database files.</summary>
            <remarks>
            tuning feature only: reserves a number of bytes in database files.
            <br/><br/>The global setting is used for the creation of new database
            files.
            <br/><br/>Without this setting, storage space will be allocated
            continuously as required. However, allocation of a fixed number
            of bytes at one time makes it more likely that the database will be
            stored in one chunk on the mass storage. Less read/write head movement
            can result in improved performance.<br/><br/>
            <b>Note:</b><br/> Allocated space will be lost on abnormal termination
            of the database engine (hardware crash, VM crash). A Defragment run
            will recover the lost space. For the best possible performance, this
            method should be called before the Defragment run to configure the
            allocation of storage space to be slightly greater than the anticipated
            database file size.
            <br/><br/>
            In client-server environment this setting should be used on the server side. <br/><br/>
            Default configuration: 0<br/><br/>
            </remarks>
            <value>the number of bytes to reserve</value>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.BlobPath">
            <summary>
            configures the path to be used to store and read
            Blob data.
            </summary>
            <remarks>
            configures the path to be used to store and read
            Blob data.
            <br/><br/>
            In client-server environment this setting should be used on the
            server side. <br/><br/>
            </remarks>
            <value>the path to be used</value>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.ReadOnly">
            <summary>turns readOnly mode on and off.</summary>
            <remarks>
            turns readOnly mode on and off.
            <br/><br/>This method configures the mode in which subsequent calls to
            <see cref="M:Db4objects.Db4o.Db4oEmbedded.OpenFile(Db4objects.Db4o.Config.IEmbeddedConfiguration,System.String)">Db4objects.Db4o.Db4oEmbedded.OpenFile(IEmbeddedConfiguration, string)</see>
            
            will open files.
            <br/><br/>Readonly mode allows to open an unlimited number of reading
            processes on one database file. It is also convenient
            for deploying db4o database files on CD-ROM.<br/><br/>
            In client-server environment this setting should be used
            ONLY on client side.<br/><br/>
            </remarks>
            <value>
            <code>true</code> for configuring readOnly mode for subsequent
            calls to
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4o.openFile()</see>
            .
            TODO: this is rather embedded + client than base?
            </value>
        </member>
        <member name="P:Db4objects.Db4o.Config.IFileConfiguration.RecoveryMode">
            <summary>
            turns recovery mode on and off.<br /><br />
            Recovery mode can be used to try to retrieve as much as possible
            out of an already corrupted database.
            </summary>
            <remarks>
            turns recovery mode on and off.<br /><br />
            Recovery mode can be used to try to retrieve as much as possible
            out of an already corrupted database. In recovery mode internal
            checks are more relaxed. Null or invalid objects may be returned
            instead of throwing exceptions.<br /><br />
            Use this method with care as a last resort to get data out of a
            corrupted database.
            </remarks>
            <value><code>true</code> to turn recover mode on.</value>
        </member>
        <member name="T:Db4objects.Db4o.Config.IFreespaceConfiguration">
            <summary>interface to configure the freespace system to be used.</summary>
            <remarks>
            interface to configure the freespace system to be used.
            <br/><br/>All methods should be called before opening database files.
            If db4o is instructed to exchange the system
            (
            <see cref="M:Db4objects.Db4o.Config.IFreespaceConfiguration.UseBTreeSystem">UseBTreeSystem()</see>
            ,
            <see cref="M:Db4objects.Db4o.Config.IFreespaceConfiguration.UseRamSystem">UseRamSystem()</see>
            )
            this will happen on opening the database file.<br/><br/>
            By default the ram based system will be used.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFreespaceConfiguration.DiscardSmallerThan(System.Int32)">
            <summary>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            </summary>
            <remarks>
            tuning feature: configures the minimum size of free space slots in the database file
            that are to be reused.
            <br /><br />When objects are updated or deleted, the space previously occupied in the
            database file is marked as "free", so it can be reused. db4o maintains two lists
            in RAM, sorted by address and by size. Adjacent entries are merged. After a large
            number of updates or deletes have been executed, the lists can become large, causing
            RAM consumption and performance loss for maintenance. With this method you can
            specify an upper bound for the byte slot size to discard.
            <br /><br />Pass <code>Integer.MAX_VALUE</code> to this method to discard all free slots for
            the best possible startup time.<br /><br />
            The downside of setting this value: Database files will necessarily grow faster.
            <br /><br />Default value:<br />
            <code>0</code> all space is reused
            </remarks>
            <param name="byteCount">Slots with this size or smaller will be lost.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFreespaceConfiguration.FreespaceFiller(Db4objects.Db4o.Config.IFreespaceFiller)">
            <summary>
            Configure a way to overwrite freed space in the database file with custom
            (for example: random) bytes.
            </summary>
            <remarks>
            Configure a way to overwrite freed space in the database file with custom
            (for example: random) bytes. Will slow down I/O operation.
            The value of this setting may be cached internally and can thus not be
            reliably set after an object container has been opened.
            </remarks>
            <param name="freespaceFiller">The freespace overwriting callback to use</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFreespaceConfiguration.UseBTreeSystem">
            <summary>configures db4o to use a BTree-based freespace system.</summary>
            <remarks>
            configures db4o to use a BTree-based freespace system.
            <br /><br /><b>Advantages</b><br />
            - ACID, no freespace is lost on abnormal system termination<br />
            - low memory consumption<br />
            <br /><b>Disadvantages</b><br />
            - slower than the RAM-based system, since freespace information
            is written during every commit<br />
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFreespaceConfiguration.UseIndexSystem">
            <summary>discontinued freespace system, only available before db4o 7.0.</summary>
            <remarks>discontinued freespace system, only available before db4o 7.0.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFreespaceConfiguration.UseRamSystem">
            <summary>configures db4o to use a RAM-based freespace system.</summary>
            <remarks>
            configures db4o to use a RAM-based freespace system.
            <br /><br /><b>Advantages</b><br />
            - best performance<br />
            <br /><b>Disadvantages</b><br />
            - upon abnormal system termination all freespace is lost<br />
            - memory consumption<br />
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Config.IFreespaceFiller">
            <summary>Callback hook for overwriting freed space in the database file.</summary>
            <remarks>Callback hook for overwriting freed space in the database file.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IFreespaceFiller.Fill(Db4objects.Db4o.IO.BlockAwareBinWindow)">
            <summary>Called to overwrite freed space in the database file.</summary>
            <remarks>Called to overwrite freed space in the database file.</remarks>
            <param name="io">Handle for the freed slot</param>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Config.ILegacyClientServerFactory">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Config.ILegacyClientServerFactory.OpenClient(Db4objects.Db4o.Config.IConfiguration,System.String,System.Int32,System.String,System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidPasswordException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Config.ILegacyClientServerFactory.OpenServer(Db4objects.Db4o.Config.IConfiguration,System.String,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Config.INameProvider">
            <summary>A provider for custom database names.</summary>
            <remarks>A provider for custom database names.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.INameProvider.Name(Db4objects.Db4o.IObjectContainer)">
            <summary>
            Derives a name for the given
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            . This method will be called when
            database startup has completed, i.e. the method will see a completely initialized
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            .
            Any code invoked during the startup process (for example
            <see cref="T:Db4objects.Db4o.Config.IConfigurationItem">IConfigurationItem</see>
            instances) will still
            see the default naming.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Config.IObjectAttribute">
            <summary>generic interface to allow returning an attribute of an object.</summary>
            <remarks>generic interface to allow returning an attribute of an object.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectAttribute.Attribute(System.Object)">
            <summary>generic method to return an attribute of a parent object.</summary>
            <remarks>generic method to return an attribute of a parent object.</remarks>
            <param name="parent">the parent object</param>
            <returns>Object - the attribute</returns>
        </member>
        <member name="T:Db4objects.Db4o.Config.IObjectClass">
            <summary>configuration interface for classes.</summary>
            <remarks>
            configuration interface for classes.
            <br/><br/>
            Use the global
            <see cref="M:Db4objects.Db4o.Config.ICommonConfiguration.ObjectClass(System.Object)">ICommonConfiguration.ObjectClass(object)
            	</see>
            to configure
            object class settings.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.CallConstructor(System.Boolean)">
            <summary>
            advises db4o to try instantiating objects of this class with/without
            calling constructors.
            </summary>
            <remarks>
            advises db4o to try instantiating objects of this class with/without
            calling constructors.
            <br/><br/>
            Not all .NET-environments support this feature. db4o will
            attempt, to follow the setting as good as the enviroment supports.
            <br/><br/>
            This setting may also be set globally for all classes in
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.CallConstructors(System.Boolean)">Db4objects.Db4o.Config.IConfiguration.CallConstructors
            </see>
            .<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="flag">
            - specify true, to request calling constructors, specify
            false to request <b>not</b> calling constructors.
            </param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.CallConstructors(System.Boolean)">Db4objects.Db4o.Config.IConfiguration.CallConstructors
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnActivate(System.Boolean)">
            <summary>sets cascaded activation behaviour.</summary>
            <remarks>
            sets cascaded activation behaviour.
            <br/><br/>
            Setting cascadeOnActivate to true will result in the activation
            of all member objects if an instance of this class is activated.
            <br/><br/>
            The default setting is <b>false</b>.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            Can be applied to an open ObjectContainer.<br/><br/>
            </remarks>
            <param name="flag">whether activation is to be cascaded to member objects.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnActivate(System.Boolean)">IObjectField.CascadeOnActivate(bool)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">Db4objects.Db4o.IObjectContainer.Activate(object, int)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnDelete(System.Boolean)">
            <summary>sets cascaded delete behaviour.</summary>
            <remarks>
            sets cascaded delete behaviour.
            <br/><br/>
            Setting CascadeOnDelete to true will result in the deletion of
            all member objects of instances of this class, if they are
            passed to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete
            </see>
            .
            <br/><br/>
            <b>Caution !</b><br/>
            This setting will also trigger deletion of old member objects, on
            calls to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store
            </see>
            .<br/><br/>
            An example of the behaviour:<br/>
            <code>
            ObjectContainer con;<br/>
            Bar bar1 = new Bar();<br/>
            Bar bar2 = new Bar();<br/>
            foo.bar = bar1;<br/>
            con.Store(foo);  // bar1 is stored as a member of foo<br/>
            foo.bar = bar2;<br/>
            con.Store(foo);  // bar2 is stored as a member of foo
            </code><br/>The last statement will <b>also</b> delete bar1 from the
            ObjectContainer, no matter how many other stored objects hold references
            to bar1.
            <br/><br/>
            The default setting is <b>false</b>.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="flag">whether deletes are to be cascaded to member objects.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnDelete(System.Boolean)">Db4objects.Db4o.Config.IObjectField.CascadeOnDelete
            </seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete
            </seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">
            <summary>sets cascaded update behaviour.</summary>
            <remarks>
            sets cascaded update behaviour.
            <br/><br/>
            Setting cascadeOnUpdate to true will result in the update
            of all member objects if a stored instance of this class is passed
            to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</see>
            .<br/><br/>
            The default setting is <b>false</b>. Setting it to true
            may result in serious performance degradation.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="flag">whether updates are to be cascaded to member objects.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate(System.Boolean)">IObjectField.CascadeOnUpdate(bool)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">Db4objects.Db4o.IObjectContainer.Set(object)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.Compare(Db4objects.Db4o.Config.IObjectAttribute)">
            <summary>registers an attribute provider for special query behavior.</summary>
            <remarks>
            registers an attribute provider for special query behavior.
            <br /><br />The query processor will compare the object returned by the
            attribute provider instead of the actual object, both for the constraint
            and the candidate persistent object.<br /><br />
            In client-server environment this setting should be used on both
            client and server. <br /><br />
            </remarks>
            <param name="attributeProvider">the attribute provider to be used</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.EnableReplication(System.Boolean)">
            <summary>
            Must be called before databases are created or opened
            so that db4o will control versions and generate UUIDs
            for objects of this class, which is required for using replication.
            </summary>
            <remarks>
            Must be called before databases are created or opened
            so that db4o will control versions and generate UUIDs
            for objects of this class, which is required for using replication.
            </remarks>
            <param name="setting"></param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.GenerateUUIDs(System.Boolean)">
            <summary>generate UUIDs for stored objects of this class.</summary>
            <remarks>
            generate UUIDs for stored objects of this class.
            This setting should be used before the database is first created.<br /><br />
            </remarks>
            <param name="setting"></param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.GenerateVersionNumbers(System.Boolean)">
            <summary>generate version numbers for stored objects of this class.</summary>
            <remarks>
            generate version numbers for stored objects of this class.
            This setting should be used before the database is first created.<br /><br />
            </remarks>
            <param name="setting"></param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.Indexed(System.Boolean)">
            <summary>turns the class index on or off.</summary>
            <remarks>
            turns the class index on or off.
            <br /><br />db4o maintains an index for each class to be able to
            deliver all instances of a class in a query. If the class
            index is never needed, it can be turned off with this method
            to improve the performance to create and delete objects of
            a class.
            <br /><br />Common cases where a class index is not needed:<br />
            - The application always works with sub classes or super classes.<br />
            - There are convenient field indexes that will always find instances
            of a class.<br />
            - The application always works with IDs.<br /><br />
            In client-server environment this setting should be used on both
            client and server. <br /><br />
            This setting can be applied to an open object container. <br /><br />
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">
            <summary>sets the maximum activation depth to the desired value.</summary>
            <remarks>
            sets the maximum activation depth to the desired value.
            <br/><br/>A class specific setting overrides the
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">global setting</see>
            <br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="depth">the desired maximum activation depth</param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnActivate(System.Boolean)">CascadeOnActivate(bool)</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.MinimumActivationDepth(System.Int32)">
            <summary>sets the minimum activation depth to the desired value.</summary>
            <remarks>
            sets the minimum activation depth to the desired value.
            <br/><br/>A class specific setting overrides the
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">global setting</see>
            <br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="depth">the desired minimum activation depth</param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnActivate(System.Boolean)">CascadeOnActivate(bool)</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.MinimumActivationDepth">
            <summary>gets the configured minimum activation depth.</summary>
            <remarks>
            gets the configured minimum activation depth.
            In client-server environment this setting should be used on both
            client and server. <br /><br />
            </remarks>
            <returns>the configured minimum activation depth.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.ObjectField(System.String)">
            <summary>
            returns an
            <see cref="T:Db4objects.Db4o.Config.IObjectField">IObjectField</see>
            object
            to configure the specified field.
            <br/><br/>
            </summary>
            <param name="fieldName">the name of the field to be configured.<br/><br/></param>
            <returns>
            an instance of an
            <see cref="T:Db4objects.Db4o.Config.IObjectField">IObjectField</see>
            object for configuration.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.PersistStaticFieldValues">
            <summary>turns on storing static field values for this class.</summary>
            <remarks>
            turns on storing static field values for this class.
            <br/><br/>By default, static field values of classes are not stored
            to the database file. By turning the setting on for a specific class
            with this switch, all <b>non-simple-typed</b> static field values of this
            class are stored the first time an object of the class is stored, and
            restored, every time a database file is opened afterwards, <b>after
            class meta information is loaded for this class</b> (which can happen
            by querying for a class or by loading an instance of a class).<br/><br/>
            To update a static field value, once it is stored, you have to the following
            in this order:<br/>
            (1) open the database file you are working agains<br/>
            (2) make sure the class metadata is loaded<br/>
            <code>objectContainer.Query().Constrain(typeof(Foo)); </code><br/>
            (3) change the static member<br/>
            (4) store the static member explicitely<br/>
            <code>objectContainer.Store(Foo.staticMember); </code>
            <br/><br/>The setting will be ignored for simple types.
            <br/><br/>Use this setting for constant static object members.
            <br/><br/>This option will slow down the process of opening database
            files and the stored objects will occupy space in the database file.
            <br/><br/>In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can NOT be applied to an open object container. <br/><br/>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.ReadAs(System.Object)">
            <summary>creates a temporary mapping of a persistent class to a different class.</summary>
            <remarks>
            creates a temporary mapping of a persistent class to a different class.
            <br /><br />If meta information for this ObjectClass has been stored to
            the database file, it will be read from the database file as if it
            was representing the class specified by the clazz parameter passed to
            this method.
            The clazz parameter can be any of the following:<br />
            - a fully qualified class name as a String.<br />
            - a Class object.<br />
            - any other object to be used as a template.<br /><br />
            This method will be ignored if the database file already contains meta
            information for clazz.
            </remarks>
            <param name="clazz">class name, Class object, or example object.<br /><br /></param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.Rename(System.String)">
            <summary>renames a stored class.</summary>
            <remarks>
            renames a stored class.
            <br /><br />Use this method to refactor classes.
            <br /><br />In client-server environment this setting should be used on both
            client and server. <br /><br />
            This setting can NOT be applied to an open object container. <br /><br />
            </remarks>
            <param name="newName">the new fully qualified class name.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.StoreTransientFields(System.Boolean)">
            <summary>allows to specify if transient fields are to be stored.</summary>
            <remarks>
            allows to specify if transient fields are to be stored.
            <br />The default for every class is <code>false</code>.<br /><br />
            In client-server environment this setting should be used on both
            client and server. <br /><br />
            This setting can be applied to an open object container. <br /><br />
            </remarks>
            <param name="flag">whether or not transient fields are to be stored.</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.Translate(Db4objects.Db4o.Config.IObjectTranslator)">
            <summary>registers a translator for this class.</summary>
            <remarks>
            registers a translator for this class.
            <br/><br/>
            <br/><br/>The use of an
            <see cref="T:Db4objects.Db4o.Config.IObjectTranslator">IObjectTranslator</see>
            is not
            compatible with the use of an
            internal class ObjectMarshaller.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="translator">
            this may be an
            <see cref="T:Db4objects.Db4o.Config.IObjectTranslator">IObjectTranslator</see>
            or an
            <see cref="T:Db4objects.Db4o.Config.IObjectConstructor">IObjectConstructor</see>
            </param>
            <seealso cref="T:Db4objects.Db4o.Config.IObjectTranslator">IObjectTranslator</seealso>
            <seealso cref="T:Db4objects.Db4o.Config.IObjectConstructor">IObjectConstructor</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">
            <summary>specifies the updateDepth for this class.</summary>
            <remarks>
            specifies the updateDepth for this class.
            <br/><br/>see the documentation of
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</see>
            for further details.<br/><br/>
            The default setting is 0: Only the object passed to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</see>
            will be updated.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            </remarks>
            <param name="depth">the depth of the desired update for this class.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.UpdateDepth(System.Int32)">IConfiguration.UpdateDepth(int)</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">CascadeOnUpdate(bool)</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate(System.Boolean)">IObjectField.CascadeOnUpdate(bool)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Config.IObjectConstructor">
            <summary>
            interface to allow instantiating objects by calling specific constructors.
            
            </summary>
            <remarks>
            interface to allow instantiating objects by calling specific constructors.
            <br/><br/>
            By writing classes that implement this interface, it is possible to
            define which constructor is to be used during the instantiation of a stored object.
            <br/><br/>
            Before starting a db4o session, translator classes that implement the
            <code>ObjectConstructor</code> or
            <see cref="T:Db4objects.Db4o.Config.IObjectTranslator">IObjectTranslator</see>
            need to be registered.<br/><br/>
            Example:<br/>
            <code>
            IConfiguration config = Db4oFactory.Configure();<br/>
            IObjectClass oc = config.ObjectClass("Namespace.ClassName");<br/>
            oc.Translate(new FooTranslator());
            </code><br/><br/>
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Config.IObjectTranslator">
            <summary>translator interface to translate objects on storage and activation.</summary>
            <remarks>
            translator interface to translate objects on storage and activation.
            <br/><br/>
            By writing classes that implement this interface, it is possible to
            define how application classes are to be converted to be stored more efficiently.
            <br/><br/>
            Before starting a db4o session, translator classes need to be registered. An example:<br/>
            <code>
            IObjectClass oc = config.ObjectClass("Namespace.ClassName");<br/>
            oc.Translate(new FooTranslator());
            </code><br/><br/>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectTranslator.OnStore(Db4objects.Db4o.IObjectContainer,System.Object)">
            <summary>db4o calls this method during storage and query evaluation.</summary>
            <remarks>db4o calls this method during storage and query evaluation.</remarks>
            <param name="container">the ObjectContainer used</param>
            <param name="applicationObject">the Object to be translated</param>
            <returns>
            return the object to store.<br/>It needs to be of the class
            <see cref="M:Db4objects.Db4o.Config.IObjectTranslator.StoredClass">StoredClass()</see>
            .
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectTranslator.OnActivate(Db4objects.Db4o.IObjectContainer,System.Object,System.Object)">
            <summary>db4o calls this method during activation.</summary>
            <remarks>db4o calls this method during activation.</remarks>
            <param name="container">the ObjectContainer used</param>
            <param name="applicationObject">the object to set the members on</param>
            <param name="storedObject">the object that was stored</param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectTranslator.StoredClass">
            <summary>return the Class you are converting to.</summary>
            <remarks>return the Class you are converting to.</remarks>
            <returns>
            the Class of the object you are returning with the method
            <see cref="M:Db4objects.Db4o.Config.IObjectTranslator.OnStore(Db4objects.Db4o.IObjectContainer,System.Object)">OnStore(Db4objects.Db4o.IObjectContainer, object)
            	</see>
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectConstructor.OnInstantiate(Db4objects.Db4o.IObjectContainer,System.Object)">
            <summary>db4o calls this method when a stored object needs to be instantiated.</summary>
            <remarks>
            db4o calls this method when a stored object needs to be instantiated.
            <br/><br/>
            </remarks>
            <param name="container">the ObjectContainer used</param>
            <param name="storedObject">
            the object stored with
            <see cref="M:Db4objects.Db4o.Config.IObjectTranslator.OnStore(Db4objects.Db4o.IObjectContainer,System.Object)">ObjectTranslator.onStore
            	</see>
            .
            </param>
            <returns>the instantiated object.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Config.IObjectField">
            <summary>configuration interface for fields of classes.</summary>
            <remarks>
            configuration interface for fields of classes.
            <br/><br/>
            Use
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.ObjectField(System.String)">IObjectClass.ObjectField(string)</see>
            to access this setting.<br/><br/>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectField.CascadeOnActivate(System.Boolean)">
            <summary>sets cascaded activation behaviour.</summary>
            <remarks>
            sets cascaded activation behaviour.
            <br/><br/>
            Setting cascadeOnActivate to true will result in the activation
            of the object attribute stored in this field if the parent object
            is activated.
            <br/><br/>
            The default setting is <b>false</b>.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="flag">whether activation is to be cascaded to the member object.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnActivate(System.Boolean)">IObjectClass.CascadeOnActivate(bool)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">Db4objects.Db4o.IObjectContainer.Activate(object, int)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectField.CascadeOnDelete(System.Boolean)">
            <summary>sets cascaded delete behaviour.</summary>
            <remarks>
            sets cascaded delete behaviour.
            <br/><br/>
            Setting cascadeOnDelete to true will result in the deletion of
            the object attribute stored in this field on the parent object
            if the parent object is passed to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete(object)
            	</see>
            .
            <br/><br/>
            <b>Caution !</b><br/>
            This setting will also trigger deletion of the old member object, on
            calls to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)"></see>
            .
            An example of the behaviour can be found in
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnDelete(System.Boolean)">IObjectClass.CascadeOnDelete(bool)
            	</see>
            <br/><br/>
            The default setting is <b>false</b>.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="flag">whether deletes are to be cascaded to the member object.</param>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnDelete(System.Boolean)">IObjectClass.CascadeOnDelete(bool)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete(object)
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate(System.Boolean)">
            <summary>sets cascaded update behaviour.</summary>
            <remarks>
            sets cascaded update behaviour.
            <br/><br/>
            Setting cascadeOnUpdate to true will result in the update
            of the object attribute stored in this field if the parent object
            is passed to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</see>
            .
            <br/><br/>
            The default setting is <b>false</b>.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can be applied to an open object container. <br/><br/>
            </remarks>
            <param name="flag">whether updates are to be cascaded to the member object.</param>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">Db4objects.Db4o.IObjectContainer.Set(object)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">IObjectClass.CascadeOnUpdate(bool)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">IObjectClass.UpdateDepth(int)</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectField.Indexed(System.Boolean)">
            <summary>turns indexing on or off.</summary>
            <remarks>
            turns indexing on or off.
            <br/><br/>Field indices dramatically improve query performance but they may
            considerably reduce storage and update performance.<br/>The best benchmark whether
            or not an index on a field achieves the desired result is the completed application
            - with a data load that is typical for it's use.<br/><br/>This configuration setting
            is only checked when the
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            is opened. If the
            setting is set to <code>true</code> and an index does not exist, the index will be
            created. If the setting is set to <code>false</code> and an index does exist the
            index will be dropped.<br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            If this setting is applied to an open ObjectContainer it will take an effect on the next
            time ObjectContainer is opened.<br/><br/>
            </remarks>
            <param name="flag">
            specify <code>true</code> or <code>false</code> to turn indexing on for
            this field
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Config.IObjectField.Rename(System.String)">
            <summary>renames a field of a stored class.</summary>
            <remarks>
            renames a field of a stored class.
            <br/><br/>Use this method to refactor classes.
            <br/><br/>
            In client-server environment this setting should be used on both
            client and server. <br/><br/>
            This setting can NOT be applied to an open object container. <br/><br/>
            </remarks>
            <param name="newName">the new field name.</param>
        </member>
        <member name="T:Db4objects.Db4o.Config.IQueryConfiguration">
            <summary>interface to configure the querying settings to be used by the query processor.
            	</summary>
            <remarks>
            interface to configure the querying settings to be used by the query processor.
            <br /><br />All settings can be configured after opening an ObjectContainer.
            In a Client/Server setup the client-side configuration will be used.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode(Db4objects.Db4o.Config.QueryEvaluationMode)">
            <summary>configures the query processor evaluation mode.</summary>
            <remarks>
            configures the query processor evaluation mode.
            <br/><br/>The db4o query processor can run in three modes:<br/>
            - <b>Immediate</b> mode<br/>
            - <b>Snapshot</b> mode<br/>
            - <b>Lazy</b> mode<br/><br/>
            In <b>Immediate</b> mode, a query will be fully evaluated when
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            
            is called. The complete
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            of all matching IDs is
            generated immediately.<br/><br/>
            In <b>Snapshot</b> mode, the
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            call will trigger all index
            processing immediately. A snapshot of the current state of all relevant indexes
            is taken for further processing by the SODA query processor. All non-indexed
            constraints and all evaluations will be run when the user application iterates
            through the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            .<br/><br/>
            In <b>Lazy</b> mode, the
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            call will only create an Iterator
            against the best index found. Further query processing (including all index
            processing) will happen when the user application iterates through the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            .<br/><br/>
            Advantages and disadvantages of the individual modes:<br/><br/>
            <b>Immediate</b> mode<br/>
            <b>+</b> If the query is intended to iterate through the entire resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            ,
            this mode will be slightly faster than the others.<br/>
            <b>+</b> The query will process without intermediate side effects from changed
            objects (by the caller or by other transactions).<br/>
            <b>-</b> Query processing can block the server for a long time.<br/>
            <b>-</b> In comparison to the other modes it will take longest until the first results
            are returned.<br/>
            <b>-</b> The ObjectSet will require a considerate amount of memory to hold the IDs of
            all found objects.<br/><br/>
            <b>Snapshot</b> mode<br/>
            <b>+</b> Index processing will happen without possible side effects from changes made
            by the caller or by other transaction.<br/>
            <b>+</b> Since index processing is fast, a server will not be blocked for a long time.<br/>
            <b>-</b> The entire candidate index will be loaded into memory. It will stay there
            until the query ObjectSet is garbage collected. In a C/S setup, the memory will
            be used on the server side.<br/><br/>
            <b>Lazy</b> mode<br/>
            <b>+</b> The call to
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            will return very fast. First results can be
            made available to the application before the query is fully processed.<br/>
            <b>+</b> A query will consume hardly any memory at all because no intermediate ID
            representation is ever created.<br/>
            <b>-</b> Lazy queries check candidates when iterating through the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            .
            In doing so the query processor takes changes into account that may have happened
            since the Query#execute()call: committed changes from other transactions, <b>and
            uncommitted changes from the calling transaction</b>. There is a wide range
            of possible side effects. The underlying index may have changed. Objects themselves
            may have changed in the meanwhile. There even is the chance of creating an endless
            loop, if the caller of the iterates through the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            and changes each
            object in a way that it is placed at the end of the index: The same objects can be
            revisited over and over. <b>In lazy mode it can make sense to work in a way one would
            work with collections to avoid concurrent modification exceptions.</b> For instance one
            could iterate through the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            first and store all objects to a temporary
            other collection representation before changing objects and storing them back to db4o.<br/><br/>
            Note: Some method calls against a lazy
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            will require the query
            processor to create a snapshot or to evaluate the query fully. An example of such
            a call is
            <see cref="!:Db4objects.Db4o.IObjectSet.Count()">Db4objects.Db4o.IObjectSet.Count()
            	</see>
            .
            <br/><br/>
            The default query evaluation mode is <b>Immediate</b> mode.
            <br/><br/>
            Recommendations:<br/>
            - <b>Lazy</b> mode can be an excellent choice for single transaction read use,
            to keep memory consumption as low as possible.<br/>
            - Client/Server applications with the risk of concurrent modifications should prefer
            <b>Snapshot</b> mode to avoid side effects from other transactions.
            <br/><br/>
            To change the evaluationMode, pass any of the three static
            <see cref="T:Db4objects.Db4o.Config.QueryEvaluationMode">QueryEvaluationMode</see>
            constants from the
            <see cref="T:Db4objects.Db4o.Config.QueryEvaluationMode">QueryEvaluationMode</see>
            class to this method:<br/>
            -
            <see cref="F:Db4objects.Db4o.Config.QueryEvaluationMode.Immediate">QueryEvaluationMode.Immediate</see>
            <br/>
            -
            <see cref="F:Db4objects.Db4o.Config.QueryEvaluationMode.Snapshot">QueryEvaluationMode.Snapshot</see>
            <br/>
            -
            <see cref="F:Db4objects.Db4o.Config.QueryEvaluationMode.Lazy">QueryEvaluationMode.Lazy</see>
            <br/><br/>
            This setting must be issued from the client side.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode">
            <seealso cref="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode(Db4objects.Db4o.Config.QueryEvaluationMode)">EvaluationMode(QueryEvaluationMode)
            	</seealso>
            <returns>the currently configured query evaluation mode</returns>
        </member>
        <member name="T:Db4objects.Db4o.Config.QueryEvaluationMode">
            <summary>
            This class provides static constants for the query evaluation
            modes that db4o supports.
            </summary>
            <remarks>
            This class provides static constants for the query evaluation
            modes that db4o supports.
            <br/><br/><b>For detailed documentation please see
            <see cref="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode(Db4objects.Db4o.Config.QueryEvaluationMode)">IQueryConfiguration.EvaluationMode(QueryEvaluationMode)
            	</see>
            </b>
            </remarks>
        </member>
        <member name="F:Db4objects.Db4o.Config.QueryEvaluationMode.Immediate">
            <summary>Constant for immediate query evaluation.</summary>
            <remarks>
            Constant for immediate query evaluation. The query is executed fully
            when
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            is called.
            <br/><br/><b>For detailed documentation please see
            <see cref="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode(Db4objects.Db4o.Config.QueryEvaluationMode)">IQueryConfiguration.EvaluationMode(QueryEvaluationMode)
            	</see>
            </b>
            </remarks>
        </member>
        <member name="F:Db4objects.Db4o.Config.QueryEvaluationMode.Snapshot">
            <summary>Constant for snapshot query evaluation.</summary>
            <remarks>
            Constant for snapshot query evaluation. When
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            is called,
            the query processor chooses the best indexes, does all index processing
            and creates a snapshot of the index at this point in time. Non-indexed
            constraints are evaluated lazily when the application iterates through
            the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            resultset of the query.
            <br/><br/><b>For detailed documentation please see
            <see cref="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode(Db4objects.Db4o.Config.QueryEvaluationMode)">IQueryConfiguration.EvaluationMode(QueryEvaluationMode)
            	</see>
            </b>
            </remarks>
        </member>
        <member name="F:Db4objects.Db4o.Config.QueryEvaluationMode.Lazy">
            <summary>Constant for lazy query evaluation.</summary>
            <remarks>
            Constant for lazy query evaluation. When
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Db4objects.Db4o.Query.IQuery.Execute()
            	</see>
            is called, the
            query processor only chooses the best index and creates an iterator on
            this index. Indexes and constraints are evaluated lazily when the
            application iterates through the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            resultset of the query.
            <br/><br/><b>For detailed documentation please see
            <see cref="M:Db4objects.Db4o.Config.IQueryConfiguration.EvaluationMode(Db4objects.Db4o.Config.QueryEvaluationMode)">IQueryConfiguration.EvaluationMode(QueryEvaluationMode)
            	</see>
            </b>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.QueryEvaluationMode.AsInt">
            <summary>internal method, ignore please.</summary>
            <remarks>internal method, ignore please.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.QueryEvaluationMode.FromInt(System.Int32)">
            <summary>internal method, ignore please.</summary>
            <remarks>internal method, ignore please.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Config.SimpleNameProvider">
            <summary>
            Assigns a fixed, pre-defined name to the given
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            .
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Config.TNull">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Config.TypeAlias">
            <summary>
            a simple Alias for a single Class or Type, using equals on
            the names in the resolve method.
            </summary>
            <remarks>
            a simple Alias for a single Class or Type, using equals on
            the names in the resolve method.
            <br/><br/>See
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            for concrete examples.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.TypeAlias.#ctor(System.String,System.String)">
            <summary>
            pass the stored name as the first
            parameter and the desired runtime name as the second parameter.
            </summary>
            <remarks>
            pass the stored name as the first
            parameter and the desired runtime name as the second parameter.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.TypeAlias.ResolveRuntimeName(System.String)">
            <summary>returns the stored type name if the alias was written for the passed runtime type name
            	</summary>
        </member>
        <member name="M:Db4objects.Db4o.Config.TypeAlias.ResolveStoredName(System.String)">
            <summary>returns the runtime type name if the alias was written for the passed stored type name
            	</summary>
        </member>
        <member name="T:Db4objects.Db4o.Config.WildcardAlias">
            <summary>
            Wildcard Alias functionality to create aliases for packages,
            namespaces or multiple similar named classes.
            </summary>
            <remarks>
            Wildcard Alias functionality to create aliases for packages,
            namespaces or multiple similar named classes. One single '*'
            wildcard character is supported in the names.
            <br/><br/>See
            <see cref="T:Db4objects.Db4o.Config.IAlias">IAlias</see>
            for concrete examples.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.WildcardAlias.#ctor(System.String,System.String)">
            <summary>
            Create a WildcardAlias with two patterns, the
            stored pattern and the pattern that is to be used
            at runtime.
            </summary>
            <remarks>
            Create a WildcardAlias with two patterns, the
            stored pattern and the pattern that is to be used
            at runtime. One single '*' is allowed as a wildcard
            character.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Config.WildcardAlias.ResolveRuntimeName(System.String)">
            <summary>resolving is done through simple pattern matching</summary>
        </member>
        <member name="M:Db4objects.Db4o.Config.WildcardAlias.ResolveStoredName(System.String)">
            <summary>resolving is done through simple pattern matching</summary>
        </member>
        <member name="T:Db4objects.Db4o.Constraints.ConstraintViolationException">
            <summary>Base class for all constraint exceptions.</summary>
            <remarks>Base class for all constraint exceptions.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Constraints.ConstraintViolationException.#ctor(System.String)">
            <summary>
            ConstraintViolationException constructor with a specific
            message.
            </summary>
            <remarks>
            ConstraintViolationException constructor with a specific
            message.
            </remarks>
            <param name="msg">exception message</param>
        </member>
        <member name="T:Db4objects.Db4o.Constraints.UniqueFieldValueConstraint">
            <summary>configures a field of a class to allow unique values only.</summary>
            <remarks>configures a field of a class to allow unique values only.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Constraints.UniqueFieldValueConstraint.#ctor(System.Object,System.String)">
            <summary>constructor to create a UniqueFieldValueConstraint.</summary>
            <remarks>constructor to create a UniqueFieldValueConstraint.</remarks>
            <param name="clazz">can be a class (Java) / Type (.NET) / instance of the class / fully qualified class name
            	</param>
            <param name="fieldName">the name of the field that is to be unique.</param>
        </member>
        <member name="M:Db4objects.Db4o.Constraints.UniqueFieldValueConstraint.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)">
            <summary>internal method, public for implementation reasons.</summary>
            <remarks>internal method, public for implementation reasons.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Constraints.UniqueFieldValueConstraintViolationException">
            <summary>
            db4o-specific exception.<br/><br/>
            This exception can be thrown by a
            <see cref="T:Db4objects.Db4o.Constraints.UniqueFieldValueConstraint">UniqueFieldValueConstraint</see>
            on commit.
            </summary>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.Indexed(System.Boolean)">Db4objects.Db4o.Config.IObjectField.Indexed(bool)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Add(Db4objects.Db4o.Config.IConfigurationItem)">Db4objects.Db4o.Config.IConfiguration.Add(Db4objects.Db4o.Config.IConfigurationItem)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Constraints.UniqueFieldValueConstraintViolationException.#ctor(System.String,System.String)">
            <summary>
            Constructor with a message composed from the class and field
            name of the entity causing the exception.
            </summary>
            <remarks>
            Constructor with a message composed from the class and field
            name of the entity causing the exception.
            </remarks>
            <param name="className">class, which caused the exception</param>
            <param name="fieldName">field, which caused the exception</param>
        </member>
        <member name="T:Db4objects.Db4o.CorruptionException">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.DTrace">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Db4oEmbedded">
            <summary>Factory class to open db4o instances in embedded
            mode.</summary>
            <remarks> Factory class to open db4o instances in embedded mode.
            </remarks>
            <seealso cref="!:Db4objects.Db4o.CS.Db4oClientServer"> Db4objects.Db4o.CS.Db4oClientServer in
            Db4objects.Db4o.CS.dll for methods to open db4o servers and db4o
            clients.</seealso>
            <since>7.5</since>
        </member>
        <member name="M:Db4objects.Db4o.Db4oEmbedded.NewConfiguration">
            <summary>
            Creates a fresh
            <see cref="T:Db4objects.Db4o.Config.IEmbeddedConfiguration">IEmbeddedConfiguration</see>
            instance.
            </summary>
            <returns>a fresh, independent configuration with all options set to their default values
            	</returns>
        </member>
        <member name="M:Db4objects.Db4o.Db4oEmbedded.OpenFile(Db4objects.Db4o.Config.IEmbeddedConfiguration,System.String)">
            <summary>
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            on the specified database file for local use.
            <br/>
            <br/>
            A database file can only be opened once, subsequent attempts to
            open another
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            against the same file will result in a
            <see cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException"> DatabaseFileLockedException</see>
            .
            <br/>
            <br/>
            Database files can only be accessed for readwrite access from one
            process at one time. All versions except for db4o mobile edition
            use an internal mechanism to lock the database file for other
            processes.
            <br/>
            <br/>
            </summary>
            <param name="config">
            a custom
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance to be obtained via
            <see cref="!:newConfiguration">newConfiguration</see>
            </param>
            <param name="databaseFileName">an absolute or relative path to the database
            file</param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.ReadOnly</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)"> Db4objects.Db4o.Config.IConfiguration.Encrypt
            </seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">
            Db4objects.Db4o.Config.IConfiguration.Password</seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"> I/O operation failed or was unexpectedly
            interrupted.</exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException"> the required database file is locked by
            another process.</exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException">
            runtime
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">configuration</see>
            is not compatible with the configuration of the database file.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file is in old format
            and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates</see>
            is set to false.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"> database was configured as read-only.
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oEmbedded.OpenFile(System.String)">
            <summary>
            Same as calling
            <see cref="M:Db4objects.Db4o.Db4oEmbedded.OpenFile(Db4objects.Db4o.Config.IEmbeddedConfiguration,System.String)">OpenFile(Db4objects.Db4o.Config.IEmbeddedConfiguration, string)
            	</see>
            with a fresh configuration (
            <see cref="M:Db4objects.Db4o.Db4oEmbedded.NewConfiguration">NewConfiguration()</see>
            ).
            </summary>
            <param name="databaseFileName">an absolute or relative path to the database file</param>
            <seealso cref="M:Db4objects.Db4o.Db4oEmbedded.OpenFile(Db4objects.Db4o.Config.IEmbeddedConfiguration,System.String)">OpenFile(Db4objects.Db4o.Config.IEmbeddedConfiguration, string)
            	</seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Db4oFactory">
            <summary>factory class to start db4o database engines.</summary>
            <remarks>
            factory class to start db4o database engines.
            <br/><br/>This class provides static methods to<br/>
            - open single-user databases
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">OpenFile(string)</see>
            <br/>
            - open db4o servers
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">OpenServer(string, int)</see>
            <br/>
            - connect to db4o servers
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenClient(System.String,System.Int32,System.String,System.String)">OpenClient(string, int, string, string)
            	</see>
            <br/>
            - provide access to the global configuration context
            <see cref="M:Db4objects.Db4o.Db4oFactory.Configure">Configure()</see>
            <br/>
            - print the version number of this db4o version
            <see cref="!:Main(java.lang.String[])">Main(java.lang.String[])</see>
            
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Ext.ExtDb4oFactory">ExtDb4o for extended functionality.
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.Main(System.String[])">
            <summary>prints the version name of this db4o version to <code>System.out</code>.
            	</summary>
            <remarks>prints the version name of this db4o version to <code>System.out</code>.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.Configure">
            <summary>
            returns the global db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            context
            for the running CLR session.
            <br/><br/>
            The
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            can be overriden in each
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Configure">ObjectContainer</see>
            .<br/><br/>
            </summary>
            <returns>
            the global
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">configuration</see>
            context
            
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.NewConfiguration">
            <summary>
            Creates a fresh
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance.
            </summary>
            <returns>a fresh, independent configuration with all options set to their default values
            	</returns>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.CloneConfiguration">
            <summary>
            Creates a clone of the global db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            .
            </summary>
            <returns>
            a fresh configuration with all option values set to the values
            currently configured for the global db4o configuration context
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenClient(System.String,System.Int32,System.String,System.String)">
            <summary>
            Operates just like
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenClient(System.String,System.Int32,System.String,System.String)">
            Db4objects.Db4o.Db4oFactory.OpenClient
            </see>, but uses
            the global db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            context.
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            client and connects it to the specified named server and port.
            <br/><br/>
            The server needs to
            <see cref="M:Db4objects.Db4o.IObjectServer.GrantAccess(System.String,System.String)">allow access</see>
            for the specified user and password.
            <br/><br/>
            A client
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            can be cast to
            <see cref="T:Db4objects.Db4o.Ext.IExtClient">IExtClient</see>
            to use extended
            <see cref="T:Db4objects.Db4o.Ext.IExtObjectContainer">IExtObjectContainer</see>
            
            and
            <see cref="T:Db4objects.Db4o.Ext.IExtClient">IExtClient</see>
            methods.
            <br/><br/>
            This method is obsolete, see the Db4objects.Db4o.CS.Db4oClientServer class in
            Db4objects.Db4o.CS.dll for methods to open db4o servers and db4o clients.
            </summary>
            <param name="config">
            a custom
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance to be obtained via
            <see cref="M:Db4objects.Db4o.Db4oEmbedded.NewConfiguration">
            Db4objects.Db4o.Db4oEmbedded.NewConfiguration
            </see>
            </param>
            <param name="hostName">the host name</param>
            <param name="port">the port the server is using</param>
            <param name="user">the user name</param>
            <param name="password">the user password</param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            </returns>
            <seealso cref="M:Db4objects.Db4o.IObjectServer.GrantAccess(System.String,System.String)">
            Db4objects.Db4o.IObjectServer.GrantAccess
            </seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">
            I/O operation failed or was unexpectedly interrupted.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file
            is in old format and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates
            </see>
            
            is set to false.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidPasswordException">
            password supplied for the connection is
            invalid.
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenClient(Db4objects.Db4o.Config.IConfiguration,System.String,System.Int32,System.String,System.String)">
            <summary>
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            client and connects it to the specified named server and port.
            <br/><br/>
            The server needs to
            <see cref="M:Db4objects.Db4o.IObjectServer.GrantAccess(System.String,System.String)">allow access</see>
            for the specified user and password.
            <br/><br/>
            A client
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            can be cast to
            <see cref="T:Db4objects.Db4o.Ext.IExtClient">IExtClient</see>
            to use extended
            <see cref="T:Db4objects.Db4o.Ext.IExtObjectContainer">IExtObjectContainer</see>
            
            and
            <see cref="T:Db4objects.Db4o.Ext.IExtClient">IExtClient</see>
            methods.
            <br/><br/>
            This method is obsolete, see the Db4objects.Db4o.CS.Db4oClientServer class in
            Db4objects.Db4o.CS.dll for methods to open db4o servers and db4o clients.
            </summary>
            <param name="config">
            a custom
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance to be obtained via
            <see cref="M:Db4objects.Db4o.Db4oEmbedded.NewConfiguration">
            Db4objects.Db4o.Db4oEmbedded.NewConfiguration
            </see>
            </param>
            <param name="hostName">the host name</param>
            <param name="port">the port the server is using</param>
            <param name="user">the user name</param>
            <param name="password">the user password</param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            </returns>
            <seealso cref="M:Db4objects.Db4o.IObjectServer.GrantAccess(System.String,System.String)">
            Db4objects.Db4o.IObjectServer.GrantAccess
            </seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">
            I/O operation failed or was unexpectedly interrupted.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file
            is in old format and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates
            </see>
            
            is set to false.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidPasswordException">
            password supplied for the connection is
            invalid.
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">
            <summary>
            Operates just like
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4oFactory.OpenFile</see>
            , but uses
            the global db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            context.
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            on the specified database file for local use.
            <br/><br/>A database file can only be opened once, subsequent attempts to open
            another
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            against the same file will result in
            a
            <see cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">DatabaseFileLockedException</see>
            .<br/><br/>
            Database files can only be accessed for readwrite access from one process
            at one time. All versions except for db4o mobile edition use an
            internal mechanism to lock the database file for other processes.
            <br/><br/>
            
            </summary>
            <param name="databaseFileName">an absolute or relative path to the database file</param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)">IConfiguration.ReadOnly</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)">IConfiguration.Encrypt</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">IConfiguration.Password</seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">
            I/O operation failed or was unexpectedly interrupted.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">
            the required database file is locked by
            another process.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException">
            runtime
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">configuration</see>
            is not compatible
            with the configuration of the database file.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file
            is in old format and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            IConfiguration.AllowVersionUpdates
            </see>
            is set to false.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException">
            database was configured as read-only.
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenFile(Db4objects.Db4o.Config.IConfiguration,System.String)">
            <summary>
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            on the specified database file for local use.
            <br/><br/>A database file can only be opened once, subsequent attempts to open
            another
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            against the same file will result in
            a
            <see cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">DatabaseFileLockedException</see>
            .<br/><br/>
            Database files can only be accessed for readwrite access from one process
            at one time. All versions except for db4o mobile edition use an
            internal mechanism to lock the database file for other processes.
            <br/><br/>
            
            </summary>
            <param name="config">
            a custom
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance to be obtained via
            <see cref="M:Db4objects.Db4o.Db4oFactory.NewConfiguration">Db4oFactory.NewConfiguration</see>
            
            </param>
            <param name="databaseFileName">an absolute or relative path to the database file</param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)">IConfiguration.ReadOnly</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)">IConfiguration.Encrypt</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">IConfiguration.Password</seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">
            I/O operation failed or was unexpectedly interrupted.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">
            the required database file is locked by
            another process.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException">
            runtime
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">configuration</see>
            is not compatible
            with the configuration of the database file.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file
            is in old format and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            IConfiguration.AllowVersionUpdates
            
            </see>
            
            is set to false.
            
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException">
            database was configured as read-only.
            
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenMemoryFile1(Db4objects.Db4o.Config.IConfiguration,Db4objects.Db4o.Ext.MemoryFile)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">
            <summary>
            Operates just like
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">
            Db4objects.Db4o.Db4oFactory.OpenServer
            </see>
            , but uses
            the global db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            context.
            Opens an
            <see cref="T:Db4objects.Db4o.IObjectServer">IObjectServer</see>
            on the specified database file and port.
            <br/><br/>
            If the server does not need to listen on a port because it will only be used
            in embedded mode with
            <see cref="M:Db4objects.Db4o.IObjectServer.OpenClient">
            Db4objects.Db4o.IObjectServer.OpenClient
            </see>
            , specify '0' as the
            port number.
            <br/><br/>This method is obsolete, see the Db4objects.Db4o.CS.Db4oClientServer class in
            Db4objects.Db4o.CS.dll for methods to open db4o servers and db4o clients.
            </summary>
            <param name="databaseFileName">an absolute or relative path to the database file</param>
            <param name="port">
            the port to be used, or 0, if the server should not open a port,
            because it will only be used with
            <see cref="M:Db4objects.Db4o.IObjectServer.OpenClient">
            Db4objects.Db4o.IObjectServer.OpenClient
            </see>
            .
            Specify a value &lt; 0 if an arbitrary free port should be chosen - see
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectServer.Port">
            Db4objects.Db4o.Ext.IExtObjectServer.Port
            </see>
            .
            </param>
            <returns>
            an
            <see cref="T:Db4objects.Db4o.IObjectServer">IObjectServer</see>
            listening
            on the specified port.
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.ReadOnly
            </seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.Encrypt
            </seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">
            Db4objects.Db4o.Config.IConfiguration.Password
            </seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">
            I/O operation failed or was unexpectedly interrupted.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">
            the required database file is locked by
            another process.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException">
            runtime
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">configuration</see>
            is not compatible
            with the configuration of the database file.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file
            is in old format and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates
            </see>
            
            is set to false.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException">
            database was configured as read-only.
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.OpenServer(Db4objects.Db4o.Config.IConfiguration,System.String,System.Int32)">
            <summary>
            opens an
            <see cref="T:Db4objects.Db4o.IObjectServer">IObjectServer</see>
            on the specified database file and port.
            <br/><br/>
            If the server does not need to listen on a port because it will only be used
            in embedded mode with
            <see cref="M:Db4objects.Db4o.IObjectServer.OpenClient">
            Db4objects.Db4o.IObjectServer.OpenClient
            </see>
            , specify '0' as the
            port number.
            <br/><br/>This method is obsolete, see the Db4objects.Db4o.CS.Db4oClientServer class in
            Db4objects.Db4o.CS.dll for methods to open db4o servers and db4o clients.
            </summary>
            <param name="config">
            a custom
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance to be obtained via
            <see cref="M:Db4objects.Db4o.Db4oEmbedded.NewConfiguration">
            Db4objects.Db4o.Db4oEmbedded.NewConfiguration
            </see>
            </param>
            <param name="databaseFileName">an absolute or relative path to the database file</param>
            <param name="port">
            the port to be used, or 0, if the server should not open a port,
            because it will only be used with
            <see cref="M:Db4objects.Db4o.IObjectServer.OpenClient">
            Db4objects.Db4o.IObjectServer.OpenClient
            </see>
            .
            Specify a value &lt; 0 if an arbitrary free port should be chosen - see
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectServer.Port">
            Db4objects.Db4o.Ext.IExtObjectServer.Port
            </see>
            .
            </param>
            <returns>
            an
            <see cref="T:Db4objects.Db4o.IObjectServer">IObjectServer</see>
            listening
            on the specified port.
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.ReadOnly
            </seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Encrypt(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.Encrypt
            </seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.Password(System.String)">
            Db4objects.Db4o.Config.IConfiguration.Password
            </seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">
            I/O operation failed or was unexpectedly interrupted.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">
            the required database file is locked by
            another process.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException">
            runtime
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">configuration</see>
            is not compatible
            with the configuration of the database file.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException">
            open operation failed because the database file
            is in old format and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">
            Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates
            </see>
            
            is set to false.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException">
            database was configured as read-only.
            </exception>
        </member>
        <member name="M:Db4objects.Db4o.Db4oFactory.Version">
            <summary>returns the version name of the used db4o version.</summary>
            <remarks>
            returns the version name of the used db4o version.
            <br /><br />
            </remarks>
            <returns>version information as a <code>String</code>.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Db4oVersion">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Debug4">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.indexAllFields">
            <summary>indexes all fields</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.queries">
            <summary>prints query graph information to the console</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.staticIdentity">
            <summary>
            allows faking the Db4oDatabase identity object, so the first
            stored object in the debugger is the actually persisted object
            Changing this setting to true will fail some tests that expect
            database files to have identity
            </summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.atHome">
            <summary>prints more stack traces</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.longTimeOuts">
            <summary>makes C/S timeouts longer, so C/S does not time out in the debugger</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.freespace">
            <summary>turns freespace debuggin on</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.xbytes">
            <summary>
            fills deleted slots with 'X' and overrides any configured
            freespace filler
            </summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.checkSychronization">
            <summary>
            checks monitor conditions to make sure only the thread
            with the global monitor is allowed entry to the core
            </summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.configureAllClasses">
            <summary>
            makes sure a configuration entry is generated for each persistent
            class
            </summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.configureAllFields">
            <summary>
            makes sure a configuration entry is generated for each persistent
            field
            </summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.weakReferences">
            <summary>allows turning weak references off</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.messages">
            <summary>prints all communicated messages to the console</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.nio">
            <summary>allows turning NIO off on Java</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.lockFile">
            <summary>allows overriding the file locking mechanism to turn it off</summary>
        </member>
        <member name="F:Db4objects.Db4o.Debug4.readBootRecord">
            <summary>
            turn to false, to prevent reading old PBootRecord object
            for debugging updating database files.
            </summary>
            <remarks>
            turn to false, to prevent reading old PBootRecord object
            for debugging updating database files.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.AbstractContextIDMapping">
            <summary>Base class for defragment ID mappings.</summary>
            <remarks>Base class for defragment ID mappings.</remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.IContextIDMapping">
            <summary>The ID mapping used internally during a defragmentation run.</summary>
            <remarks>The ID mapping used internally during a defragmentation run.</remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IContextIDMapping.MappedID(System.Int32,System.Boolean)">
            <summary>Returns a previously registered mapping ID for the given ID if it exists.
            	</summary>
            <remarks>
            Returns a previously registered mapping ID for the given ID if it exists.
            If lenient mode is set to true, will provide the mapping ID for the next
            smaller original ID a mapping exists for. Otherwise returns 0.
            </remarks>
            <param name="origID">The original ID</param>
            <param name="lenient">If true, lenient mode will be used for lookup, strict mode otherwise.
            	</param>
            <returns>The mapping ID for the given original ID or 0, if none has been registered.
            	</returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IContextIDMapping.MapIDs(System.Int32,System.Int32,System.Boolean)">
            <summary>Registers a mapping for the given IDs.</summary>
            <remarks>Registers a mapping for the given IDs.</remarks>
            <param name="origID">The original ID</param>
            <param name="mappedID">The ID to be mapped to the original ID.</param>
            <param name="isClassID">true if the given original ID specifies a class slot, false otherwise.
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IContextIDMapping.Open">
            <summary>Prepares the mapping for use.</summary>
            <remarks>Prepares the mapping for use.</remarks>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IContextIDMapping.Close">
            <summary>Shuts down the mapping after use.</summary>
            <remarks>Shuts down the mapping after use.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.BTreeIDMapping">
            <summary>BTree mapping for IDs during a defragmentation run.</summary>
            <remarks>BTree mapping for IDs during a defragmentation run.</remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.BTreeIDMapping.#ctor(System.String)">
            <summary>Will maintain the ID mapping as a BTree in the file with the given path.
            	</summary>
            <remarks>
            Will maintain the ID mapping as a BTree in the file with the given path.
            If a file exists in this location, it will be DELETED.
            Node size and cache height of the tree will be the default values used by
            the BTree implementation. The tree will never commit.
            </remarks>
            <param name="fileName">The location where the BTree file should be created.</param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.BTreeIDMapping.#ctor(System.String,System.Int32,System.Int32)">
            <summary>Will maintain the ID mapping as a BTree in the file with the given path.
            	</summary>
            <remarks>
            Will maintain the ID mapping as a BTree in the file with the given path.
            If a file exists in this location, it will be DELETED.
            </remarks>
            <param name="fileName">The location where the BTree file should be created.</param>
            <param name="nodeSize">The size of a BTree node</param>
            <param name="commitFrequency">The number of inserts after which a commit should be issued (&lt;=0: never commit)
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.BTreeIDMapping.Open">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.Defragment">
            <summary>defragments database files.</summary>
            <remarks>
            defragments database files.
            <br/>
            <br/>
            db4o structures storage inside database files as free and occupied
            slots, very much like a file system - and just like a file system it
            can be fragmented.
            <br/>
            <br/>
            The simplest way to defragment a database file:
            <br/>
            <br/>
            <code>Defragment.Defrag("sample.yap");
            </code>
            <br/>
            <br/>
            This will move the file to "sample.yap.backup", then create a
            defragmented version of this file in the original position, using a
            temporary file "sample.yap.mapping". If the backup file already
            exists, this will throw an exception and no action will be taken.
            <br/>
            <br/>
            For more detailed configuration of the defragmentation process,
            provide a DefragmentConfig instance:
            <br/>
            <br/>
            <code>
            DefragmentConfig config=new
            DefragmentConfig("sample.yap","sample.bap",new
            BTreeIDMapping("sample.map"));
            <br/>
            config.ForceBackupDelete(true);
            <br/>
            config.StoredClassFilter(new AvailableClassFilter());
            <br/>
            config.Db4oConfig(db4oConfig);
            <br/>
            Defragment.Defrag(config);
            </code>
            <br/>
            <br/>
            This will move the file to "sample.bap", then create a defragmented
            version of this file in the original position, using a temporary
            file "sample.map" for BTree mapping. If the backup file already
            exists, it will be deleted. The defragmentation process will skip
            all classes that have instances stored within the yap file, but that
            are not available on the class path (through the current
            classloader). Custom db4o configuration options are read from the
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            passed as db4oConfig.
            <strong>Note:</strong>
            For some specific, non-default configuration settings like UUID
            generation, etc., you
            <strong>must</strong>
            pass an appropriate db4o configuration, just like you'd use it
            within your application for normal database operation.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.Defrag(System.String)">
            <summary>
            Renames the file at the given original path to a backup file and then
            builds a defragmented version of the file in the original place.
            </summary>
            <remarks>
            Renames the file at the given original path to a backup file and then
            builds a defragmented version of the file in the original place.
            </remarks>
            <param name="origPath">The path to the file to be defragmented.</param>
            <exception cref="T:System.IO.IOException">if the original file cannot be moved to the backup location
            	</exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.Defrag(System.String,System.String)">
            <summary>
            Renames the file at the given original path to the given backup file and
            then builds a defragmented version of the file in the original place.
            </summary>
            <remarks>
            Renames the file at the given original path to the given backup file and
            then builds a defragmented version of the file in the original place.
            </remarks>
            <param name="origPath">The path to the file to be defragmented.</param>
            <param name="backupPath">The path to the backup file to be created.</param>
            <exception cref="T:System.IO.IOException">if the original file cannot be moved to the backup location
            	</exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.Defrag(Db4objects.Db4o.Defragment.DefragmentConfig)">
            <summary>
            Renames the file at the configured original path to the configured backup
            path and then builds a defragmented version of the file in the original
            place.
            </summary>
            <remarks>
            Renames the file at the configured original path to the configured backup
            path and then builds a defragmented version of the file in the original
            place.
            </remarks>
            <param name="config">The configuration for this defragmentation run.</param>
            <exception cref="T:System.IO.IOException">if the original file cannot be moved to the backup location
            	</exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.Defrag(Db4objects.Db4o.Defragment.DefragmentConfig,Db4objects.Db4o.Defragment.IDefragmentListener)">
            <summary>
            Renames the file at the configured original path to the configured backup
            path and then builds a defragmented version of the file in the original
            place.
            </summary>
            <remarks>
            Renames the file at the configured original path to the configured backup
            path and then builds a defragmented version of the file in the original
            place.
            </remarks>
            <param name="config">The configuration for this defragmentation run.</param>
            <param name="listener">
            A listener for status notifications during the defragmentation
            process.
            </param>
            <exception cref="T:System.IO.IOException">if the original file cannot be moved to the backup location
            	</exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.MoveToBackup(Db4objects.Db4o.Defragment.DefragmentConfig)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.CopyBin(Db4objects.Db4o.IO.IStorage,Db4objects.Db4o.IO.IStorage,System.String,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.EnsureFileExists(Db4objects.Db4o.IO.IStorage,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.UpgradeFile(Db4objects.Db4o.Defragment.DefragmentConfig)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.FirstPass(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Defragment.DefragmentConfig)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.SecondPass(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Defragment.DefragmentConfig)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.Pass(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Defragment.DefragmentConfig,Db4objects.Db4o.Defragment.IPassCommand)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.ProcessClass(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,Db4objects.Db4o.Defragment.IPassCommand)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.ProcessClassAndFieldIndices(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,Db4objects.Db4o.Defragment.IPassCommand)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.Defragment.ProcessClassIndex(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,Db4objects.Db4o.Defragment.IPassCommand)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ISlotCopyHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IVisitor4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.IDefragmentListener">
            <summary>Listener for defragmentation process messages.</summary>
            <remarks>Listener for defragmentation process messages.</remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IDefragmentListener.NotifyDefragmentInfo(Db4objects.Db4o.Defragment.DefragmentInfo)">
            <summary>
            This method will be called when the defragment process encounters
            file layout anomalies during the defragmentation process.
            </summary>
            <remarks>
            This method will be called when the defragment process encounters
            file layout anomalies during the defragmentation process.
            </remarks>
            <param name="info">The message from the defragmentation process.</param>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.DefragmentConfig">
            <summary>Configuration for a defragmentation run.</summary>
            <remarks>Configuration for a defragmentation run.</remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.#ctor(System.String)">
            <summary>Creates a configuration for a defragmentation run.</summary>
            <remarks>
            Creates a configuration for a defragmentation run. The backup and mapping
            file paths are generated from the original path by appending the default
            suffixes. All properties other than the provided paths are set to FALSE
            by default.
            </remarks>
            <param name="origPath">
            The path to the file to be defragmented. Must exist and must be
            a valid db4o file.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.#ctor(System.String,System.String)">
            <summary>Creates a configuration for a defragmentation run with in-memory mapping.
            	</summary>
            <remarks>
            Creates a configuration for a defragmentation run with in-memory mapping.
            All properties other than the provided paths are set to FALSE by default.
            </remarks>
            <param name="origPath">
            The path to the file to be defragmented. Must exist and must be
            a valid db4o file.
            </param>
            <param name="backupPath">
            The path to the backup of the original file. No file should
            exist at this position, otherwise it will be OVERWRITTEN if forceBackupDelete()
            is set to true!
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.#ctor(System.String,System.String,Db4objects.Db4o.Defragment.IContextIDMapping)">
            <summary>Creates a configuration for a defragmentation run.</summary>
            <remarks>
            Creates a configuration for a defragmentation run. All properties other
            than the provided paths are set to FALSE by default.
            </remarks>
            <param name="origPath">
            The path to the file to be defragmented. Must exist and must be
            a valid db4o file.
            </param>
            <param name="backupPath">
            The path to the backup of the original file. No file should
            exist at this position, otherwise it will be OVERWRITTEN if forceBackupDelete()
            is set to true!
            </param>
            <param name="mapping">The intermediate mapping used internally.</param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.OrigPath">
            <returns>The path to the file to be defragmented.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.BackupPath">
            <returns>The path to the backup of the original file.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.Mapping">
            <returns>The intermediate mapping used internally. For internal use only.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.StoredClassFilter">
            <returns>
            The
            <see cref="T:Db4objects.Db4o.Defragment.IStoredClassFilter">IStoredClassFilter</see>
            used to select stored class extents to
            be included into the defragmented file.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.StoredClassFilter(Db4objects.Db4o.Defragment.IStoredClassFilter)">
            <param name="storedClassFilter">
            The
            <see cref="T:Db4objects.Db4o.Defragment.IStoredClassFilter">IStoredClassFilter</see>
            used to select stored class extents to
            be included into the defragmented file.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.ForceBackupDelete">
            <returns>true, if an existing backup file should be deleted, false otherwise.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.ForceBackupDelete(System.Boolean)">
            <param name="forceBackupDelete">true, if an existing backup file should be deleted, false otherwise.
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.ReadOnly(System.Boolean)">
            <summary>
            allows turning on and off readonly mode.<br /><br />
            When changed classes are likely to be detected defragment, it may be required
            to open the original database in read/write mode.
            </summary>
            <remarks>
            allows turning on and off readonly mode.<br /><br />
            When changed classes are likely to be detected defragment, it may be required
            to open the original database in read/write mode. <br /><br />
            Readonly mode is the default setting.
            </remarks>
            <param name="flag">false, to turn off readonly mode.</param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.ReadOnly">
            <returns>true, if the original database file is to be opened in readonly mode.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.Db4oConfig">
            <returns>
            The db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            to be applied
            during the defragment process.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.Db4oConfig(Db4objects.Db4o.Config.IConfiguration)">
            <param name="config">
            The db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            to be applied
            during the defragment process.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.Db4oConfig(Db4objects.Db4o.Config.IEmbeddedConfiguration)">
            <param name="config">
            The db4o
            <see cref="T:Db4objects.Db4o.Config.IEmbeddedConfiguration">IEmbeddedConfiguration</see>
            to be applied
            during the defragment process.
            </param>
            <since>7.9</since>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.ObjectCommitFrequency(System.Int32)">
            <param name="objectCommitFrequency">
            The number of processed object (slots) that should trigger an
            intermediate commit of the target file. Default: 0, meaning: never.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentConfig.UpgradeFile(System.String)">
            <summary>
            Instruct the defragment process to upgrade the source file to the current db4o
            version prior to defragmenting it.
            </summary>
            <remarks>
            Instruct the defragment process to upgrade the source file to the current db4o
            version prior to defragmenting it. Use this option if your source file has been created
            with an older db4o version than the one you are using.
            </remarks>
            <param name="tempPath">The location for an intermediate, upgraded version of the source file.
            	</param>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.IStoredClassFilter">
            <summary>Filter for StoredClass instances.</summary>
            <remarks>Filter for StoredClass instances.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IStoredClassFilter.Accept(Db4objects.Db4o.Ext.IStoredClass)">
            <param name="storedClass">StoredClass instance to be checked</param>
            <returns>true, if the given StoredClass instance should be accepted, false otherwise.
            	</returns>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.DefragmentInfo">
            <summary>A message from the defragmentation process.</summary>
            <remarks>
            A message from the defragmentation process. This is a stub only
            and will be refined.
            Currently instances of these class will only be created and sent
            to registered listeners when invalid IDs are encountered during
            the defragmentation process. These probably are harmless and the
            result of a user-initiated delete operation.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.DefragmentServicesImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.IDefragmentServices">
            <summary>Encapsulates services involving source and target database files during defragmenting.
            	</summary>
            <remarks>Encapsulates services involving source and target database files during defragmenting.
            	</remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Mapping.IIDMapping">
            <summary>A mapping from db4o file source IDs/addresses to target IDs/addresses, used for defragmenting.
            	</summary>
            <remarks>A mapping from db4o file source IDs/addresses to target IDs/addresses, used for defragmenting.
            	</remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Mapping.IIDMapping.MappedID(System.Int32)">
            <returns>a mapping for the given id. if it does refer to a system handler or the empty reference (0), returns the given id.
            	</returns>
            <exception cref="T:Db4objects.Db4o.Internal.Mapping.MappingNotFoundException">if the given id does not refer to a system handler or the empty reference (0) and if no mapping is found
            	</exception>
            <exception cref="T:Db4objects.Db4o.Internal.Mapping.MappingNotFoundException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IDefragmentServices.SourceBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IDefragmentServices.TargetBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.#ctor(Db4objects.Db4o.Defragment.DefragmentConfig,Db4objects.Db4o.Defragment.IDefragmentListener)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.FreshTempFile(System.String,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.FreshTargetFile(Db4objects.Db4o.Defragment.DefragmentConfig)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.MappedID(System.Int32)">
            <exception cref="T:Db4objects.Db4o.Internal.Mapping.MappingNotFoundException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.MappedID(System.Int32,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Internal.Mapping.MappingNotFoundException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.InternalMappedID(System.Int32,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Internal.Mapping.MappingNotFoundException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.SourceBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.TargetBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.DefragmentServicesImpl.TargetStatefulBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.ArgumentException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IProcedure4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.FirstPassCommand">
            <summary>
            First step in the defragmenting process: Allocates pointer slots in the target file for
            each ID (but doesn't fill them in, yet) and registers the mapping from source pointer address
            to target pointer address.
            </summary>
            <remarks>
            First step in the defragmenting process: Allocates pointer slots in the target file for
            each ID (but doesn't fill them in, yet) and registers the mapping from source pointer address
            to target pointer address.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.IPassCommand">
            <summary>Implements one step in the defragmenting process.</summary>
            <remarks>Implements one step in the defragmenting process.</remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IPassCommand.ProcessObjectSlot(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,System.Int32)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IPassCommand.ProcessClass(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IPassCommand.ProcessClassCollection(Db4objects.Db4o.Defragment.DefragmentServicesImpl)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.IPassCommand.ProcessBTree(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.Btree.BTree)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.FirstPassCommand.ProcessClassCollection(Db4objects.Db4o.Defragment.DefragmentServicesImpl)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.TraverseFieldCommand">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.ITraverseAspectCommand">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.SecondPassCommand">
            <summary>
            Second step in the defragmenting process: Fills in target file pointer slots, copies
            content slots from source to target and triggers ID remapping therein by calling the
            appropriate db4o/marshaller defrag() implementations.
            </summary>
            <remarks>
            Second step in the defragmenting process: Fills in target file pointer slots, copies
            content slots from source to target and triggers ID remapping therein by calling the
            appropriate db4o/marshaller defrag() implementations. During the process, the actual address
            mappings for the content slots are registered for use with string indices.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.SecondPassCommand.ProcessClass(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.SecondPassCommand.ProcessObjectSlot(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.ClassMetadata,System.Int32)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.SecondPassCommand.ProcessClassCollection(Db4objects.Db4o.Defragment.DefragmentServicesImpl)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Defragment.SecondPassCommand.ProcessBTree(Db4objects.Db4o.Defragment.DefragmentServicesImpl,Db4objects.Db4o.Internal.Btree.BTree)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Defragment.TreeIDMapping">
            <summary>In-memory mapping for IDs during a defragmentation run.</summary>
            <remarks>In-memory mapping for IDs during a defragmentation run.</remarks>
            <seealso cref="T:Db4objects.Db4o.Defragment.Defragment">Defragment</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Deploy">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Deploy.debug">
            <summary>turning debug on makes the file format human readable</summary>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.ClassHasNoFields">
            <summary>Diagnostic, if class has no fields.</summary>
            <remarks>Diagnostic, if class has no fields.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.DiagnosticBase">
            <summary>base class for Diagnostic messages</summary>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.IDiagnostic">
            <summary>
            Marker interface for Diagnostic messages<br/><br/>
            Diagnostic system can be enabled on a running db4o database
            to notify a user about possible problems or misconfigurations.
            </summary>
            <remarks>
            Marker interface for Diagnostic messages<br/><br/>
            Diagnostic system can be enabled on a running db4o database
            to notify a user about possible problems or misconfigurations. Diagnostic
            messages must implement this interface and are usually derived from
            <see cref="T:Db4objects.Db4o.Diagnostic.DiagnosticBase">DiagnosticBase</see>
            class. A separate Diagnostic implementation
            should be used for each problem.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Diagnostic.DiagnosticBase">DiagnosticBase</seealso>
            <seealso cref="T:Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration">IDiagnosticConfiguration</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.DiagnosticBase.Reason">
            <summary>returns the reason for the message</summary>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.DiagnosticBase.Problem">
            <summary>returns the potential problem that triggered the message</summary>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.DiagnosticBase.Solution">
            <summary>suggests a possible solution for the possible problem</summary>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.DefragmentRecommendation">
            <summary>Diagnostic to recommend Defragment when needed.</summary>
            <remarks>Diagnostic to recommend Defragment when needed.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.DeletionFailed">
            <summary>Diagnostic on failed delete.</summary>
            <remarks>Diagnostic on failed delete.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.DescendIntoTranslator">
            <summary>
            Query tries to descend into a field of a class that is configured to be translated
            (and thus cannot be descended into).
            </summary>
            <remarks>
            Query tries to descend into a field of a class that is configured to be translated
            (and thus cannot be descended into).
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.DiagnosticToConsole">
            <summary>prints Diagnostic messsages to the Console.</summary>
            <remarks>
            prints Diagnostic messages to the Console.
            Install this
            <see cref="T:Db4objects.Db4o.Diagnostic.IDiagnosticListener">Db4objects.Db4o.Diagnostic.IDiagnosticListener
            </see>
            with: <br/>
            <code>commonConfig.Diagnostic.AddListener(new DiagnosticToConsole());</code><br/>
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration">Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration
            </seealso>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.IDiagnosticListener">
            <summary>listens to Diagnostic messages.</summary>
            <remarks>
            listens to Diagnostic messages.
            <br/><br/>Create a class that implements this listener interface and add
            the listener by calling <code>commonConfig.Diagnostic.AddListener()</code>.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration">Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.IDiagnosticListener.OnDiagnostic(Db4objects.Db4o.Diagnostic.IDiagnostic)">
            <summary>this method will be called with Diagnostic messages.</summary>
            <remarks>this method will be called with Diagnostic messages.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.DiagnosticToConsole.OnDiagnostic(Db4objects.Db4o.Diagnostic.IDiagnostic)">
            <summary>redirects Diagnostic messages to the Console.</summary>
            <remarks>redirects Diagnostic messages to the Console.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration">
            <summary>provides methods to configure the behaviour of db4o
            diagnostics.</summary>
            <remarks>
            provides methods to configure the behaviour of db4o diagnostics.
            <br/>
            <br/>
            Diagnostic system can be enabled on a running db4o database to
            notify a user about possible problems or misconfigurations.
            Diagnostic listeners can be be added and removed with calls to this
            interface. To install the most basic listener call:
            <br/>
            <code>commonConfig.Diagnostic.AddListener(new
            DiagnosticToConsole());</code>
            </remarks>
            <seealso cref="!:IConfiguration.Diagnostic">IConfiguration.Diagnostic
            </seealso>
            <seealso cref="T:Db4objects.Db4o.Diagnostic.IDiagnosticListener">IDiagnosticListener
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration.AddListener(Db4objects.Db4o.Diagnostic.IDiagnosticListener)">
            <summary>adds a DiagnosticListener to listen to Diagnostic messages.</summary>
            <remarks>adds a DiagnosticListener to listen to Diagnostic messages.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.IDiagnosticConfiguration.RemoveAllListeners">
            <summary>removes all DiagnosticListeners.</summary>
            <remarks>removes all DiagnosticListeners.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.LoadedFromClassIndex">
            <summary>Diagnostic, if query was required to load candidate set from class index.
            	</summary>
            <remarks>Diagnostic, if query was required to load candidate set from class index.
            	</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.NativeQueryNotOptimized">
            <summary>Diagnostic, if Native Query can not be run optimized.</summary>
            <remarks>Diagnostic, if Native Query can not be run optimized.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.ObjectFieldDoesNotExist">
            <summary>
            Diagnostic if
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.ObjectField(System.String)">Db4objects.Db4o.Config.IObjectClass.ObjectField(string)
            	</see>
            was called on a
            field that does not exist.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.UpdateDepthGreaterOne">
            <summary>Diagnostic, if update depth greater than 1.</summary>
            <remarks>Diagnostic, if update depth greater than 1.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">
            <summary>Argument for object related events which can be cancelled.</summary>
            <remarks>Argument for object related events which can be cancelled.</remarks>
            <seealso cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</seealso>
            <seealso cref="T:Db4objects.Db4o.Events.ICancellableEventArgs">ICancellableEventArgs</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Events.ObjectEventArgs">
            <summary>Arguments for object related events.</summary>
            <remarks>Arguments for object related events.</remarks>
            <seealso cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Events.ObjectEventArgs.#ctor(Db4objects.Db4o.Internal.Transaction)">
            <summary>Creates a new instance for the specified object.</summary>
            <remarks>Creates a new instance for the specified object.</remarks>
        </member>
        <member name="P:Db4objects.Db4o.Events.ObjectEventArgs.Object">
            <summary>The object that triggered this event.</summary>
            <remarks>The object that triggered this event.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Events.ICancellableEventArgs">
            <summary>Argument for events related to cancellable actions.</summary>
            <remarks>Argument for events related to cancellable actions.</remarks>
            <seealso cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Events.ICancellableEventArgs.Cancel">
            <summary>Cancels the action related to this event.</summary>
            <remarks>
            Cancels the action related to this event.
            Although the related action will be cancelled all the registered
            listeners will still receive the event.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Events.ICancellableEventArgs.IsCancelled">
            <summary>Queries if the action was already cancelled by some event listener.</summary>
            <remarks>Queries if the action was already cancelled by some event listener.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.#ctor(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Ext.IObjectInfo,System.Object)">
            <summary>Creates a new instance for the specified object.</summary>
            <remarks>Creates a new instance for the specified object.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.Cancel">
            <seealso cref="M:Db4objects.Db4o.Events.ICancellableEventArgs.Cancel">ICancellableEventArgs.Cancel()</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Events.CancellableObjectEventArgs.IsCancelled">
            <seealso cref="P:Db4objects.Db4o.Events.ICancellableEventArgs.IsCancelled">ICancellableEventArgs.IsCancelled()
            	</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Events.CommitEventArgs">
            <summary>Arguments for commit time related events.</summary>
            <remarks>Arguments for commit time related events.</remarks>
            <seealso cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</seealso>
        </member>
        <member name="P:Db4objects.Db4o.Events.CommitEventArgs.Added">
            <summary>Returns a iteration</summary>
        </member>
        <member name="T:Db4objects.Db4o.Events.EventException">
            <summary>
            db4o-specific exception.<br/><br/>
            Exception thrown during event dispatching if a client
            provided event handler throws.<br/><br/>
            The exception thrown by the client can be retrieved by
            calling EventException.InnerException.
            </summary>
            <remarks>
            db4o-specific exception.<br/><br/>
            Exception thrown during event dispatching if a client
            provided event handler throws.<br/><br/>
            The exception thrown by the client can be retrieved by
            calling EventException.InnerException.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Events.EventRegistryFactory">
            <summary>
            Provides an interface for getting an
            <see cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</see>
            from an
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            .
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Events.EventRegistryFactory.ForObjectContainer(Db4objects.Db4o.IObjectContainer)">
            <summary>
            Returns an
            <see cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</see>
            for registering events with the specified container.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Events.IEventRegistry">
            <summary>
            Provides a way to register event handlers for specific <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see> events.<br/>
            EventRegistry methods represent events available for registering callbacks.
            EventRegistry instance can be obtained from <see cref="T:Db4objects.Db4o.Events.EventRegistryFactory">EventRegistryFactory</see>.
            <code>EventRegistry registry =  EventRegistryFactory.ForObjectContainer(container);</code>
            A new callback can be registered for an event with the following code:
            <code>
            private static void OnCreated(object sender, ObjectInfoEventArgs args)
            {
            Object obj = args.Object;
            if (obj is Pilot)
            {
            Console.WriteLine(obj.ToString());
            }
            }
            registry.Created+=new System.EventHandler&lt;ObjectInfoEventArgs&gt;(OnCreated);
            </code>
            <seealso cref="T:Db4objects.Db4o.Events.EventRegistryFactory">EventRegistryFactory</seealso>
            </summary>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.QueryStarted">
            <summary>
            This event is fired upon a query start and can be used to gather
            query statistics.
            </summary>
            <remarks>
            This event is fired upon a query start and can be used to gather
            query statistics.
            The query object is available from
            <see cref="T:Db4objects.Db4o.Events.QueryEventArgs">QueryEventArgs</see>
            event parameter.<br/>
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.QueryEventArgs">QueryEventArgs</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.QueryFinished">
            <summary>
            This event is fired upon a query end and can be used to gather
            query statistics.
            </summary>
            <remarks>
            This event is fired upon a query end and can be used to gather
            query statistics.
            The query object is available from
            <see cref="T:Db4objects.Db4o.Events.QueryEventArgs">QueryEventArgs</see>
            event parameter.<br/>
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.QueryEventArgs">QueryEventArgs</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Creating">
            <summary>This event is fired before an object is saved for the first time.</summary>
            <remarks>
            This event is fired before an object is saved for the first time.
            The object can be obtained from
            <see cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</see>
            event parameter. The action can be cancelled using
            <see cref="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.Cancel">CancellableObjectEventArgs.Cancel()
            	</see>
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Activating">
            <summary>This event is fired before an object is activated.</summary>
            <remarks>
            This event is fired before an object is activated.
            The object can be obtained from
            <see cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</see>
            event parameter. The action can be cancelled using
            <see cref="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.Cancel">CancellableObjectEventArgs.Cancel()
            	</see>
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">Db4objects.Db4o.IObjectContainer.Activate(object, int)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Updating">
            <summary>This event is fired before an object is updated.</summary>
            <remarks>
            This event is fired before an object is updated.
            The object can be obtained from
            <see cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</see>
            event parameter. The action can be cancelled using
            <see cref="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.Cancel">CancellableObjectEventArgs.Cancel()
            	</see>
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Deleting">
            <summary>This event is fired before an object is deleted.</summary>
            <remarks>
            This event is fired before an object is deleted.
            The object can be obtained from
            <see cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</see>
            event parameter. The action can be cancelled using
            <see cref="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.Cancel">CancellableObjectEventArgs.Cancel()
            	</see>
            <br/><br/>
            Note, that this event is not available in networked client/server
            mode and will throw an exception when attached to a client ObjectContainer.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Deactivating">
            <summary>This event is fired before an object is deactivated.</summary>
            <remarks>
            This event is fired before an object is deactivated.
            The object can be obtained from
            <see cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</see>
            event parameter. The action can be cancelled using
            <see cref="M:Db4objects.Db4o.Events.CancellableObjectEventArgs.Cancel">CancellableObjectEventArgs.Cancel()
            	</see>
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CancellableObjectEventArgs">CancellableObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Deactivate(System.Object,System.Int32)">Db4objects.Db4o.IObjectContainer.Deactivate(object, int)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Activated">
            <summary>This event is fired after an object is activated.</summary>
            <remarks>
            This event is fired after an object is activated.
            The object can be obtained from the
            <see cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</see>
            event parameter. <br/><br/>
            The event can be used to trigger some post-activation
            functionality.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">Db4objects.Db4o.IObjectContainer.Activate(object, int)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Created">
            <summary>This event is fired after an object is created (saved for the first time).
            	</summary>
            <remarks>
            This event is fired after an object is created (saved for the first time).
            The object can be obtained from the
            <see cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</see>
            event parameter.<br/><br/>
            The event can be used to trigger some post-creation
            functionality.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ObjectEventArgs">ObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Updated">
            <summary>This event is fired after an object is updated.</summary>
            <remarks>
            This event is fired after an object is updated.
            The object can be obtained from the
            <see cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</see>
            event parameter.<br/><br/>
            The event can be used to trigger some post-update
            functionality.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Deleted">
            <summary>This event is fired after an object is deleted.</summary>
            <remarks>
            This event is fired after an object is deleted.
            The object can be obtained from the
            <see cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</see>
            event parameter.<br/><br/>
            The event can be used to trigger some post-deletion
            functionality.<br/><br/>
            Note, that this event is not available in networked client/server
            mode and will throw an exception when attached to a client ObjectContainer.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ObjectEventArgs">ObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Deactivated">
            <summary>This event is fired after an object is deactivated.</summary>
            <remarks>
            This event is fired after an object is deactivated.
            The object can be obtained from the
            <see cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</see>
            event parameter.<br/><br/>
            The event can be used to trigger some post-deactivation
            functionality.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ObjectEventArgs">ObjectEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">Db4objects.Db4o.IObjectContainer.Delete(object)
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Committing">
            <summary>This event is fired just before a transaction is committed.</summary>
            <remarks>
            This event is fired just before a transaction is committed.
            The transaction and a list of the modified objects can
            be obtained from the
            <see cref="T:Db4objects.Db4o.Events.CommitEventArgs">CommitEventArgs</see>
            event parameter.<br/><br/>
            Committing event gives a user a chance to interrupt the commit
            and rollback the transaction.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CommitEventArgs">CommitEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Commit">Db4objects.Db4o.IObjectContainer.Commit()
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Committed">
            <summary>This event is fired after a transaction has been committed.</summary>
            <remarks>
            This event is fired after a transaction has been committed.
            The transaction and a list of the modified objects can
            be obtained from the
            <see cref="T:Db4objects.Db4o.Events.CommitEventArgs">CommitEventArgs</see>
            event parameter.<br/><br/>
            The event can be used to trigger some post-commit functionality.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.CommitEventArgs">CommitEventArgs</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Commit">Db4objects.Db4o.IObjectContainer.Commit()
            	</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Instantiated">
            <summary>This event is fired when a persistent object is instantiated.</summary>
            <remarks>
            This event is fired when a persistent object is instantiated.
            The object can be obtained from the
            <see cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</see>
            event parameter.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ObjectInfoEventArgs">ObjectInfoEventArgs</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.ClassRegistered">
            <summary>This event is fired when a new class is registered with metadata.</summary>
            <remarks>
            This event is fired when a new class is registered with metadata.
            The class information can be obtained from
            <see cref="T:Db4objects.Db4o.Events.ClassEventArgs">ClassEventArgs</see>
            event parameter.
            </remarks>
            <returns>event</returns>
            <seealso cref="T:Db4objects.Db4o.Events.ClassEventArgs">ClassEventArgs</seealso>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Closing">
            <summary>
            This event is fired when the
            <see cref="M:Db4objects.Db4o.IObjectContainer.Close">Db4objects.Db4o.IObjectContainer.Close()
            	</see>
            is
            called.
            </summary>
            <returns>event</returns>
        </member>
        <member name="E:Db4objects.Db4o.Events.IEventRegistry.Opened">
            <summary>
            This event is fired when the
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            has
            finished its startup procedure.
            </summary>
            <returns>event</returns>
        </member>
        <member name="T:Db4objects.Db4o.Events.ObjectContainerEventArgs">
            <summary>Arguments for container related events.</summary>
            <remarks>Arguments for container related events.</remarks>
            <seealso cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Events.QueryEventArgs">
            <summary>
            Arguments for
            <see cref="T:Db4objects.Db4o.Query.IQuery">Db4objects.Db4o.Query.IQuery</see>
            related events.
            </summary>
            <seealso cref="T:Db4objects.Db4o.Events.IEventRegistry">IEventRegistry</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Events.QueryEventArgs.#ctor(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Query.IQuery)">
            <summary>
            Creates a new instance for the specified
            <see cref="T:Db4objects.Db4o.Query.IQuery">Db4objects.Db4o.Query.IQuery</see>
            instance.
            </summary>
        </member>
        <member name="P:Db4objects.Db4o.Events.QueryEventArgs.Query">
            <summary>
            The
            <see cref="T:Db4objects.Db4o.Query.IQuery">Db4objects.Db4o.Query.IQuery</see>
            which triggered the event.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Events.StringEventArgs">
            <since>7.12</since>
        </member>
        <member name="T:Db4objects.Db4o.Ext.BackupInProgressException">
            <summary>db4o-specific exception.</summary>
            <remarks>
            db4o-specific exception. <br/><br/>
            This exception is thrown when the current
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Backup(System.String)">backup</see>
            process encounters another backup process already running.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.DatabaseClosedException">
            <summary>db4o-specific exception.</summary>
            <remarks>
            db4o-specific exception. <br/><br/>
            This exception is thrown when the object container required for
            the current operation was closed or failed to open.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile(string)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Close">Db4objects.Db4o.IObjectContainer.Close()
            	</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.DatabaseFileLockedException">
            <summary>
            db4o-specific exception.<br/><br/>
            this Exception is thrown during any of the db4o open calls
            if the database file is locked by another process.
            </summary>
            <remarks>
            db4o-specific exception.<br/><br/>
            this Exception is thrown during any of the db4o open calls
            if the database file is locked by another process.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Db4oFactory.OpenFile(System.String)">Db4objects.Db4o.Db4oFactory.OpenFile(string)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.DatabaseFileLockedException.#ctor(System.String)">
            <summary>Constructor with a database description message</summary>
            <param name="databaseDescription">message, which can help to identify the database
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.DatabaseFileLockedException.#ctor(System.String,System.Exception)">
            <summary>Constructor with a database description and cause exception</summary>
            <param name="databaseDescription">database description</param>
            <param name="cause">previous exception caused DatabaseFileLockedException</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.DatabaseMaximumSizeReachedException">
            <summary>
            db4o-specific exception.<br/><br/>
            This exception is thrown when the database file reaches the
            maximum allowed size.
            </summary>
            <remarks>
            db4o-specific exception.<br/><br/>
            This exception is thrown when the database file reaches the
            maximum allowed size. Upon throwing the exception the database is
            switched to the read-only mode. <br/>
            The maximum database size is configurable
            and can reach up to 254GB.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.BlockSize(System.Int32)">Db4objects.Db4o.Config.IConfiguration.BlockSize(int)
            	</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException">
            <summary>
            db4o-specific exception.<br/><br/>
            This exception is thrown when a write operation is attempted
            on a database in a read-only mode.
            </summary>
            <remarks>
            db4o-specific exception.<br/><br/>
            This exception is thrown when a write operation is attempted
            on a database in a read-only mode.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ReadOnly(System.Boolean)"></seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Db4oDatabase">
            <summary>Class to identify a database by it's signature.</summary>
            <remarks>
            Class to identify a database by it's signature.
            <br /><br />db4o UUID handling uses a reference to the Db4oDatabase object, that
            represents the database an object was created on.
            </remarks>
            <persistent></persistent>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Types.IDb4oType">
            <summary>marker interface for all special db4o types.</summary>
            <remarks>marker interface for all special db4o types.</remarks>
        </member>
        <member name="F:Db4objects.Db4o.Ext.Db4oDatabase.i_signature">
            <summary>Field is public for implementation reasons, DO NOT TOUCH!</summary>
        </member>
        <member name="F:Db4objects.Db4o.Ext.Db4oDatabase.i_uuid">
            <summary>
            Field is public for implementation reasons, DO NOT TOUCH!
            This field is badly named, it really is the creation time.
            </summary>
            <remarks>
            Field is public for implementation reasons, DO NOT TOUCH!
            This field is badly named, it really is the creation time.
            </remarks>
        </member>
        <member name="F:Db4objects.Db4o.Ext.Db4oDatabase.i_stream">
            <summary>cached ObjectContainer for getting the own ID.</summary>
            <remarks>cached ObjectContainer for getting the own ID.</remarks>
        </member>
        <member name="F:Db4objects.Db4o.Ext.Db4oDatabase.i_id">
            <summary>cached ID, only valid in combination with i_objectContainer</summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.#ctor">
            <summary>constructor for persistence</summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.#ctor(System.Byte[],System.Int64)">
            <summary>constructor for comparison and to store new ones</summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.Generate">
            <summary>generates a new Db4oDatabase object with a unique signature.</summary>
            <remarks>generates a new Db4oDatabase object with a unique signature.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.Equals(System.Object)">
            <summary>comparison by signature.</summary>
            <remarks>comparison by signature.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.GetID(Db4objects.Db4o.Internal.Transaction)">
            <summary>gets the db4o ID, and may cache it for performance reasons.</summary>
            <remarks>gets the db4o ID, and may cache it for performance reasons.</remarks>
            <returns>the db4o ID for the ObjectContainer</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.GetSignature">
            <summary>returns the unique signature</summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.Bind(Db4objects.Db4o.Internal.Transaction)">
            <summary>make sure this Db4oDatabase is stored.</summary>
            <remarks>make sure this Db4oDatabase is stored. Return the ID.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oDatabase.Query(Db4objects.Db4o.Internal.Transaction)">
            <summary>find a Db4oDatabase with the same signature as this one</summary>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Db4oIOException">
            <summary>
            db4o-specific exception.<br /><br />
            This exception is thrown when a system IO exception
            is encounted by db4o process.
            </summary>
            <remarks>
            db4o-specific exception.<br /><br />
            This exception is thrown when a system IO exception
            is encounted by db4o process.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oIOException.#ctor">
            <summary>Constructor.</summary>
            <remarks>Constructor.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oIOException.#ctor(System.Exception)">
            <summary>Constructor allowing to specify the causing exception</summary>
            <param name="cause">exception cause</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Db4oIllegalStateException">
            <summary>
            The requested operation is not valid in the current state but the database
            continues to operate.
            </summary>
            <remarks>
            The requested operation is not valid in the current state but the database
            continues to operate.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Db4oUUID">
            <summary>a unique universal identify for an object.</summary>
            <remarks>
            a unique universal identify for an object. <br/><br/>The db4o UUID consists of
            two parts:<br/> - an indexed long for fast access,<br/> - the signature of the
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            the object was created with.
            <br/><br/>Db4oUUIDs are valid representations of objects over multiple
            ObjectContainers
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oUUID.#ctor(System.Int64,System.Byte[])">
            <summary>constructs a Db4oUUID from a long part and a signature part</summary>
            <param name="longPart_">the long part</param>
            <param name="signaturePart_">the signature part</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oUUID.GetLongPart">
            <summary>returns the long part of this UUID.</summary>
            <remarks>
            returns the long part of this UUID. <br /><br />To uniquely identify an object
            universally, db4o uses an indexed long and a reference to the
            Db4oDatabase object it was created on.
            </remarks>
            <returns>the long part of this UUID.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.Db4oUUID.GetSignaturePart">
            <summary>returns the signature part of this UUID.</summary>
            <remarks>
            returns the signature part of this UUID. <br/><br/> <br/><br/>To uniquely
            identify an object universally, db4o uses an indexed long and a reference to
            the Db4oDatabase singleton object of the
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            it was created on. This method
            returns the signature of the Db4oDatabase object of the ObjectContainer: the
            signature of the origin ObjectContainer.
            </remarks>
            <returns>the signature of the Db4oDatabase for this UUID.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Db4oUnexpectedException">
            <summary>Unexpected fatal error is encountered.</summary>
            <remarks>Unexpected fatal error is encountered.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.EmergencyShutdownReadOnlyException">
            <summary>
            A previous IO exception has switched the database file
            to read-only mode for controlled shutdown.
            </summary>
            <remarks>
            A previous IO exception has switched the database file
            to read-only mode for controlled shutdown.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.ExtDb4oFactory">
            <summary>extended factory class with static methods to open special db4o sessions.
            	</summary>
            <remarks>extended factory class with static methods to open special db4o sessions.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">
            <summary>
            Operates just like
            <see cref="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">ExtDb4oFactory.OpenMemoryFile</see>
            , but uses
            the global db4o
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            context.
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            for in-memory use .
            <br/><br/>In-memory ObjectContainers are useful for maximum performance
            on small databases, for swapping objects or for storing db4o format data
            to other media or other databases.<br/><br/>Be aware of the danger of running
            into OutOfMemory problems or complete loss of all data, in case of hardware
            or software failures.<br/><br/>
            
            </summary>
            <param name="memoryFile">
            a
            <see cref="T:Db4objects.Db4o.Ext.MemoryFile">MemoryFile</see>
            
            to store the raw byte data.
            
            </param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            
            </returns>
            <seealso cref="T:Db4objects.Db4o.Ext.MemoryFile">MemoryFile</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Config.IConfiguration,Db4objects.Db4o.Ext.MemoryFile)">
            <summary>
            opens an
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            for in-memory use .
            <br/><br/>In-memory ObjectContainers are useful for maximum performance
            on small databases, for swapping objects or for storing db4o format data
            to other media or other databases.<br/><br/>Be aware of the danger of running
            into OutOfMemory problems or complete loss of all data, in case of hardware
            or software failures.<br/><br/>
            
            </summary>
            <param name="config">
            a custom
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            instance to be obtained via
            <see cref="M:Db4objects.Db4o.Db4oFactory.NewConfiguration">Db4oFactory.NewConfiguration</see>
            
            </param>
            <param name="memoryFile">
            a
            <see cref="T:Db4objects.Db4o.Ext.MemoryFile">MemoryFile</see>
            
            to store the raw byte data.
            
            </param>
            <returns>
            an open
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            
            </returns>
            <seealso cref="T:Db4objects.Db4o.Ext.MemoryFile">MemoryFile</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IDb4oCallback">
            <summary>generic callback interface.</summary>
            <remarks>generic callback interface.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IDb4oCallback.Callback(System.Object)">
            <summary>the callback method</summary>
            <param name="obj">the object passed to the callback method</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IExtClient">
            <summary>
            extended client functionality for the
            <see cref="T:Db4objects.Db4o.Ext.IExtObjectContainer">IExtObjectContainer</see>
            interface.
            <br/><br/>Both
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenClient(System.String,System.Int32,System.String,System.String)">Db4o.openClient()
            	</see>
            methods always
            return an <code>ExtClient</code> object so a cast is possible.<br/><br/>
            The ObjectContainer functionality is split into multiple interfaces to allow newcomers to
            focus on the essential methods.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IExtObjectContainer">
            <summary>
            extended functionality for the
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            interface.
            <br/><br/>Every db4o
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            always is an <code>ExtObjectContainer</code> so a cast is possible.<br/><br/>
            <see cref="M:Db4objects.Db4o.IObjectContainer.Ext">ObjectContainer.ext()</see>
            is a convenient method to perform the cast.<br/><br/>
            The ObjectContainer functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.IObjectContainer">
            <summary>the interface to a db4o database, stand-alone or client/server.</summary>
            <remarks>
            the interface to a db4o database, stand-alone or client/server.
            <br/><br/>The IObjectContainer interface provides methods
            to store, query and delete objects and to commit and rollback
            transactions.<br/><br/>
            An IObjectContainer can either represent a stand-alone database
            or a connection to a
            <see cref="!:Db4objects.Db4o.Db4o.OpenServer">db4o server</see>
            .
            <br/><br/>An IObjectContainer also represents a transaction. All work
            with db4o always is transactional. Both
            <see cref="M:Db4objects.Db4o.IObjectContainer.Commit">Db4objects.Db4o.IObjectContainer.Commit</see>
            and
            <see cref="M:Db4objects.Db4o.IObjectContainer.Rollback">Db4objects.Db4o.IObjectContainer.Rollback</see>
            start new transactions immediately. For working
            against the same database with multiple transactions, open a db4o server
            with
            <see cref="!:Db4objects.Db4o.Db4o.OpenServer">Db4objects.Db4o.Db4o.OpenServer</see>
            and
            <see cref="!:Db4objects.Db4o.ObjectServer.OpenClient">connect locally</see>
            or
            <see cref="!:Db4objects.Db4o.Db4o.OpenClient">over TCP</see>
            .
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Ext.IExtObjectContainer">IExtObjectContainer for extended functionality.
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Query.ISodaQueryFactory.Query">
            <summary>
            creates a new SODA
            <see cref="T:Db4objects.Db4o.Query.IQuery">Query</see>
            .
            <br/><br/>
            Linq queries are the recommended main db4o query interface.
            <br/><br/>
            Use
            <see cref="M:Db4objects.Db4o.IObjectContainer.QueryByExample(System.Object)">QueryByExample(Object template)</see>
            for simple Query-By-Example.<br/><br/>
            </summary>
            <returns>a new IQuery object</returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Activate(System.Object,System.Int32)">
            <summary>activates all members on a stored object to the specified depth.</summary>
            <remarks>
            activates all members on a stored object to the specified depth.
            <br/><br/>
            See
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">"Why activation"</see>
            for an explanation why activation is necessary.<br/><br/>
            The activate method activates a graph of persistent objects in memory.
            Only deactivated objects in the graph will be touched: their
            fields will be loaded from the database.
            The activate methods starts from a
            root object and traverses all member objects to the depth specified by the
            depth parameter. The depth parameter is the distance in "field hops"
            (object.field.field) away from the root object. The nodes at 'depth' level
            away from the root (for a depth of 3: object.member.member) will be instantiated
            but deactivated, their fields will be null.
            The activation depth of individual classes can be overruled
            with the methods
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">MaximumActivationDepth()
            	</see>
            and
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.MinimumActivationDepth(System.Int32)">MinimumActivationDepth()
            	</see>
            in the
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">ObjectClass interface</see>
            .<br/><br/>
            A successful call to activate triggers Activating and Activated callback methods,
            which can be used for cascaded activation.<br/><br/>
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">Why activation?</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
            <param name="obj">the object to be activated.</param>
            <param name="depth">
            the member
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">depth</see>
            to which activate is to cascade.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Close">
            <summary>closes this IObjectContainer.</summary>
            <remarks>
            closes this IObjectContainer.
            <br/><br/>A call to Close() automatically performs a
            <see cref="M:Db4objects.Db4o.IObjectContainer.Commit">Commit()</see>
            .
            <br/><br/>Note that every session opened with Db4oFactory.OpenFile() requires one
            Close()call, even if the same filename was used multiple times.<br/><br/>
            Use <code>while(!Close()){}</code> to kill all sessions using this container.<br/><br/>
            </remarks>
            <returns>
            success - true denotes that the last used instance of this container
            and the database file were closed.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Commit">
            <summary>commits the running transaction.</summary>
            <remarks>
            commits the running transaction.
            <br /><br />Transactions are back-to-back. A call to commit will starts
            a new transaction immedidately.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Deactivate(System.Object,System.Int32)">
            <summary>deactivates a stored object by setting all members to <code>NULL</code>.
            	</summary>
            <remarks>
            deactivates a stored object by setting all members to <code>NULL</code>.
            <br/>Primitive types will be set to their default values.
            Calls to this method save memory.
            The method has no effect, if the passed object is not stored in the
            <code>IObjectContainer</code>.<br/><br/>
            <code>Deactivate()</code> triggers Deactivating and Deactivated callbacks.
            <br/><br/>
            Be aware that calling this method with a depth parameter greater than
            1 sets members on member objects to null. This may have side effects
            in other places of the application.<br/><br/>
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">Why activation?</seealso>
            <param name="obj">the object to be deactivated.</param>
            <param name="depth">
            the member
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">depth</see>
            
            to which deactivate is to cascade.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Delete(System.Object)">
            <summary>deletes a stored object permanently.</summary>
            <remarks>
            deletes a stored object permanently.
            <br/><br/>Note that this method has to be called <b>for every single object
            individually</b>. Delete does not recurse to object members. Simple
            and array member types are destroyed.
            <br/><br/>Object members of the passed object remain untouched, unless
            cascaded deletes are
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnDelete(System.Boolean)">configured for the class</see>
            or for
            <see cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnDelete(System.Boolean)">one of the member fields</see>
            .
            <br/><br/>The method has no effect, if
            the passed object is not stored in the <code>IObjectContainer</code>.
            <br/><br/>A subsequent call to
            <code>Store()</code> with the same object newly stores the object
            to the <code>IObjectContainer</code>.<br/><br/>
            <code>Delete()</code> triggers Deleting and Deleted callbacks,
            which can be also used for cascaded deletes.<br/><br/>
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnDelete(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CascadeOnDelete
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnDelete(System.Boolean)">Db4objects.Db4o.Config.IObjectField.CascadeOnDelete
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
            <param name="obj">
            the object to be deleted from the
            <code>IObjectContainer</code>.<br/>
            </param>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Ext">
            <summary>returns an IObjectContainer with extended functionality.</summary>
            <remarks>
            returns an IObjectContainer with extended functionality.
            <br /><br />Every IObjectContainer that db4o provides can be casted to
            an IExtObjectContainer. This method is supplied for your convenience
            to work without a cast.
            <br /><br />The IObjectContainer functionality is split to two interfaces
            to allow newcomers to focus on the essential methods.<br /><br />
            </remarks>
            <returns>this, casted to IExtObjectContainer</returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Get(System.Object)">
            <summary>Query-By-Example interface to retrieve objects.</summary>
            <remarks>
            Query-By-Example interface to retrieve objects.
            <br/><br/><code>Get()</code> creates an
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            containing
            all objects in the <code>IObjectContainer</code> that match the passed
            template object.<br/><br/>
            Calling <code>Get(NULL)</code> returns all objects stored in the
            <code>IObjectContainer</code>.<br/><br/><br/>
            <b>Query Evaluation</b>
            <br/>All non-null members of the template object are compared against
            all stored objects of the same class.
            Primitive type members are ignored if they are 0 or false respectively.
            <br/><br/>Arrays and all supported <code>Collection</code> classes are
            evaluated for containment. Differences in <code>Length/Count/Size()</code> are
            ignored.
            <br/><br/>Consult the documentation of the IConfiguration package to
            configure class-specific behaviour.<br/><br/><br/>
            <b>Returned Objects</b><br/>
            The objects returned in the
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            are instantiated
            and activated to the preconfigured depth of 5. The
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">activation depth</see>
            may be configured
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">globally</see>
            or
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">individually for classes</see>
            .
            <br/><br/>
            db4o keeps track of all instantiatied objects. Queries will return
            references to these objects instead of instantiating them a second time.
            <br/><br/>
            Objects newly activated by <code>Get()</code> can respond to the Activating callback
            method.
            <br/><br/>
            </remarks>
            <param name="template">object to be used as an example to find all matching objects.<br/><br/>
            	</param>
            <returns>
            
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            containing all found objects.<br/><br/>
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">Why activation?</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.QueryByExample(System.Object)">
            <summary>Query-By-Example interface to retrieve objects.</summary>
            <remarks>
            Query-By-Example interface to retrieve objects.
            <br/><br/><code>QueryByExample()</code> creates an
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            containing
            all objects in the <code>IObjectContainer</code> that match the passed
            template object.<br/><br/>
            Calling <code>QueryByExample(null)</code> returns all objects stored in the
            <code>IObjectContainer</code>.<br/><br/><br/>
            <b>Query Evaluation</b>
            <br/>All non-null members of the template object are compared against
            all stored objects of the same class.
            Primitive type members are ignored if they are 0 or false respectively.
            <br/><br/>Arrays and all supported <code>Collection</code> classes are
            evaluated for containment. Differences in <code>Length/Count/Size()</code> are
            ignored.
            <br/><br/>Consult the documentation of the IConfiguration package to
            configure class-specific behaviour.<br/><br/><br/>
            <b>Returned Objects</b><br/>
            The objects returned in the
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            are instantiated
            and activated to the preconfigured depth of 5. The
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">activation depth</see>
            may be configured
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">globally</see>
            or
            <see cref="T:Db4objects.Db4o.Config.IObjectClass">individually for classes</see>
            .
            <br/><br/>
            db4o keeps track of all instantiatied objects. Queries will return
            references to these objects instead of instantiating them a second time.
            <br/><br/>
            Objects newly activated by <code>QueryByExample()</code> can respond to the Activating callback
            method.
            <br/><br/>
            </remarks>
            <param name="template">object to be used as an example to find all matching objects.<br/><br/>
            	</param>
            <returns>
            
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            containing all found objects.<br/><br/>
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">Why activation?</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query">
            <summary>
            creates a new SODA
            <see cref="T:Db4objects.Db4o.Query.IQuery">Query</see>
            .
            <br/><br/>
            Linq queries are the recommended main db4o query interface.
            <br/><br/>
            Use
            <see cref="M:Db4objects.Db4o.IObjectContainer.QueryByExample(System.Object)">QueryByExample(Object template)</see>
            for simple Query-By-Example.<br/><br/>
            </summary>
            <returns>a new IQuery object</returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query(System.Type)">
            <summary>queries for all instances of a class.</summary>
            <remarks>queries for all instances of a class.</remarks>
            <param name="clazz">the class to query for.</param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            returned by the query.
            </returns>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate)" -->
        <member name="M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate,Db4objects.Db4o.Query.IQueryComparator)">
            <summary>Native Query Interface.</summary>
            <remarks>
            Native Query Interface. Queries as with
            <see cref="M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate)">Db4objects.Db4o.IObjectContainer.Query(Predicate)</see>
            ,
            but will sort the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            according to the given
            <see cref="T:Db4objects.Db4o.Query.IQueryComparator">Db4objects.Db4o.Query.IQueryComparator</see>
            .
            </remarks>
            <param name="predicate">
            the
            <see cref="T:Db4objects.Db4o.Query.Predicate">Db4objects.Db4o.Query.Predicate</see>
            containing the native query expression.
            </param>
            <param name="comparator">
            the
            <see cref="T:Db4objects.Db4o.Query.IQueryComparator">Db4objects.Db4o.Query.IQueryComparator</see>
            specifiying the sort order of the result
            </param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            returned by the query.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate,System.Collections.IComparer)">
            <summary>Native Query Interface.</summary>
            <remarks>
            Native Query Interface. Queries as with
            <see cref="M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate)">Db4objects.Db4o.IObjectContainer.Query(Predicate)</see>
            ,
            but will sort the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            according to the given
            <see cref="T:System.Collections.IComparer">System.Collections.IComparer</see>
            .
            </remarks>
            <param name="predicate">
            the
            <see cref="T:Db4objects.Db4o.Query.Predicate">Db4objects.Db4o.Query.Predicate</see>
            containing the native query expression.
            </param>
            <param name="comparator">
            the
            <see cref="T:System.Collections.IComparer">System.Collections.IComparer</see>
            specifiying the sort order of the result
            </param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            returned by the query.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Rollback">
            <summary>rolls back the running transaction.</summary>
            <remarks>
            rolls back the running transaction.
            <br/><br/>Transactions are back-to-back. A call to rollback will starts
            a new transaction immedidately.
            <br/><br/>rollback will not restore modified objects in memory. They
            can be refreshed from the database by calling
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Refresh(System.Object,System.Int32)">Db4objects.Db4o.Ext.IExtObjectContainer.Refresh
            	</see>
            .
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">
            <summary>newly stores objects or updates stored objects.</summary>
            <remarks>
            newly stores objects or updates stored objects.
            <br/><br/>An object not yet stored in the <code>IObjectContainer</code> will be
            stored when it is passed to <code>Set()</code>. An object already stored
            in the <code>IObjectContainer</code> will be updated.
            <br/><br/><b>Updates</b><br/>
            - will affect all simple type object members.<br/>
            - links to object members that are already stored will be updated.<br/>
            - new object members will be newly stored. The algorithm traverses down
            new members, as long as further new members are found.<br/>
            - object members that are already stored will <b>not</b> be updated
            themselves.<br/>Every object member needs to be updated individually with a
            call to <code>Set()</code> unless a deep
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.UpdateDepth(System.Int32)">global</see>
            or
            <see cref="!:Db4objects.Db4o.Config.ObjectClass.UpdateDepth">class-specific</see>
            update depth was configured or cascaded updates were
            <see cref="!:Db4objects.Db4o.Config.ObjectClass.CascadeOnUpdate">defined in the class</see>
            or in
            <see cref="!:Db4objects.Db4o.Config.ObjectField.CascadeOnUpdate">one of the member fields</see>
            .
            Depending if the passed object is newly stored or updated, Creating/Created or
            Updaing/Updated callback method is triggered.
            Callbacks
            might also be used for cascaded updates.<br/><br/>
            </remarks>
            <param name="obj">the object to be stored or updated.</param>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Set(System.Object,System.Int32)">IExtObjectContainer#Set(object, depth)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.UpdateDepth(System.Int32)">Db4objects.Db4o.Config.IConfiguration.UpdateDepth
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">Db4objects.Db4o.Config.IObjectClass.UpdateDepth
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate(System.Boolean)">Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">
            <summary>newly stores objects or updates stored objects.</summary>
            <remarks>
            newly stores objects or updates stored objects.
            <br/><br/>An object not yet stored in the <code>IObjectContainer</code> will be
            stored when it is passed to <code>Store()</code>. An object already stored
            in the <code>IObjectContainer</code> will be updated.
            <br/><br/><b>Updates</b><br/>
            - will affect all simple type object members.<br/>
            - links to object members that are already stored will be updated.<br/>
            - new object members will be newly stored. The algorithm traverses down
            new members, as long as further new members are found.<br/>
            - object members that are already stored will <b>not</b> be updated
            themselves.<br/>Every object member needs to be updated individually with a
            call to <code>Store()</code> unless a deep
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.UpdateDepth(System.Int32)">global</see>
            or
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">class-specific</see>
            update depth was configured or cascaded updates were
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">defined in the class</see>
            or in
            <see cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate(System.Boolean)">one of the member fields</see>
            .
            Depending if the passed object is newly stored or updated, Creating/Created or
            Updaing/Updated callback method is triggered.
            Callbacks
            might also be used for cascaded updates.<br/><br/>
            </remarks>
            <param name="obj">the object to be stored or updated.</param>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Store(System.Object,System.Int32)">IExtObjectContainer#Store(object, depth)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.UpdateDepth(System.Int32)">Db4objects.Db4o.Config.IConfiguration.UpdateDepth
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.UpdateDepth(System.Int32)">Db4objects.Db4o.Config.IObjectClass.UpdateDepth
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate(System.Boolean)">Db4objects.Db4o.Config.IObjectClass.CascadeOnUpdate
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate(System.Boolean)">Db4objects.Db4o.Config.IObjectField.CascadeOnUpdate
            	</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectCallbacks">Using callbacks</seealso>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Db4objects.Db4o.IObjectContainer.Query``1(System.Predicate{``0})" -->
        <member name="M:Db4objects.Db4o.IObjectContainer.Query``1(System.Predicate{``0},System.Collections.Generic.IComparer{``0})">
            <summary>Native Query Interface.</summary>
            <remarks>
            Native Query Interface. Queries as with
            <see cref="M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate)">Db4objects.Db4o.IObjectContainer.Query(Predicate)</see>
            ,
            but will sort the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            according to the given
            <see cref="!:System.Collections.Generic.IComparer">System.Collections.Generic.IComparer</see>
            .
            </remarks>
            <param name="predicate">
            the
            <see cref="T:Db4objects.Db4o.Query.Predicate">Db4objects.Db4o.Query.Predicate</see>
            containing the native query expression.
            </param>
            <param name="comparator">
            the
            <see cref="!:System.Collections.Generic.IComparer">System.Collections.Generic.IComparer</see>
            specifiying the sort order of the result
            </param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            returned by the query.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query``1(System.Predicate{``0},System.Comparison{``0})">
            <summary>Native Query Interface.</summary>
            <remarks>
            Native Query Interface. Queries as with
            <see cref="M:Db4objects.Db4o.IObjectContainer.Query(Db4objects.Db4o.Query.Predicate)">Db4objects.Db4o.IObjectContainer.Query(Predicate)</see>
            ,
            but will sort the resulting
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            according to the given
            <see cref="!:System.Comparison">System.Comparison</see>
            .
            </remarks>
            <param name="predicate">
            the
            <see cref="T:Db4objects.Db4o.Query.Predicate">Db4objects.Db4o.Query.Predicate</see>
            containing the native query expression.
            </param>
            <param name="comparator">
            the
            <see cref="!:System.Comparison">System.Comparison</see>
            specifiying the sort order of the result
            </param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            returned by the query.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query``1(System.Type)">
            <summary>
            queries for all instances of the type extent, returning
            a IList of ElementType which must be assignable from
            extent.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query``1">
            <summary>
            queries for all instances of the type extent.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.IObjectContainer.Query``1(System.Collections.Generic.IComparer{``0})">
            <summary>
            queries for all instances of the type extent sorting with the specified comparer.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Activate(System.Object)">
            <summary>activates an object with the current activation strategy.</summary>
            <remarks>
            activates an object with the current activation strategy.
            In regular activation mode the object will be activated to the
            global activation depth, ( see
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Db4objects.Db4o.Config.IConfiguration.ActivationDepth()
            	</see>
            )
            and all configured settings for
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(int)
            	</see>
            
            and
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(int)
            	</see>
            will be respected.<br/><br/>
            In Transparent Activation Mode ( see
            <see cref="T:Db4objects.Db4o.TA.TransparentActivationSupport">Db4objects.Db4o.TA.TransparentActivationSupport
            	</see>
            )
            the parameter object will only be activated, if it does not implement
            <see cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</see>
            . All referenced members that do not implement
            <see cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</see>
            will also be activated. Any
            <see cref="T:Db4objects.Db4o.TA.IActivatable">Db4objects.Db4o.TA.IActivatable</see>
            objects
            along the referenced graph will break cascading activation.
            </remarks>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Deactivate(System.Object)">
            <summary>deactivates an object.</summary>
            <remarks>
            deactivates an object.
            Only the passed object will be deactivated, i.e, no object referenced by this
            object will be deactivated.
            </remarks>
            <param name="obj">the object to be deactivated.</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Backup(System.String)">
            <summary>backs up a database file of an open ObjectContainer.</summary>
            <remarks>
            backs up a database file of an open ObjectContainer.
            <br/><br/>While the backup is running, the ObjectContainer can continue to be
            used. Changes that are made while the backup is in progress, will be applied to
            the open ObjectContainer and to the backup.<br/><br/>
            While the backup is running, the ObjectContainer should not be closed.<br/><br/>
            If a file already exists at the specified path, it will be overwritten.<br/><br/>
            The
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            used for backup is the one configured for this container.
            </remarks>
            <param name="path">a fully qualified path</param>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:System.NotSupportedException">
            is thrown when the operation is not supported in current
            configuration/environment
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">I/O operation failed or was unexpectedly interrupted.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Backup(Db4objects.Db4o.IO.IStorage,System.String)">
            <summary>backs up a database file of an open ObjectContainer.</summary>
            <remarks>
            backs up a database file of an open ObjectContainer.
            <br/><br/>While the backup is running, the ObjectContainer can continue to be
            used. Changes that are made while the backup is in progress, will be applied to
            the open ObjectContainer and to the backup.<br/><br/>
            While the backup is running, the ObjectContainer should not be closed.<br/><br/>
            If a file already exists at the specified path, it will be overwritten.<br/><br/>
            This method is intended for cross-storage backups, i.e. backup from an in-memory
            database to a file.
            </remarks>
            <param name="targetStorage">
            the
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            to be used for backup
            </param>
            <param name="path">a fully qualified path</param>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:System.NotSupportedException">
            is thrown when the operation is not supported in current
            configuration/environment
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">I/O operation failed or was unexpectedly interrupted.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Bind(System.Object,System.Int64)">
            <summary>binds an object to an internal object ID.</summary>
            <remarks>
            binds an object to an internal object ID.
            <br/><br/>This method uses the ID parameter to load the
            corresponding stored object into memory and replaces this memory
            reference with the object parameter. The method may be used to replace
            objects or to reassociate an object with it's stored instance
            after closing and opening a database file. A subsequent call to
            <see cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">set(Object)</see>
            is
            necessary to update the stored object.<br/><br/>
            <b>Requirements:</b><br/>- The ID needs to be a valid internal object ID,
            previously retrieved with
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetID(System.Object)">getID(Object)</see>
            .<br/>
            - The object parameter needs to be of the same class as the stored object.<br/><br/>
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetID(System.Object)">GetID(object)</seealso>
            <param name="obj">the object that is to be bound</param>
            <param name="id">the internal id the object is to be bound to</param>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException">
            when the provided id is outside the scope of the
            database IDs.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Configure">
            <summary>returns the Configuration context for this ObjectContainer.</summary>
            <remarks>
            returns the Configuration context for this ObjectContainer.
            <br/><br/>
            Upon opening an ObjectContainer with any of the factory methods in the
            <see cref="T:Db4objects.Db4o.Db4oFactory">Db4o class</see>
            , the global
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            context
            is copied into the ObjectContainer. The
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            can be modified individually for
            each ObjectContainer without any effects on the global settings.<br/><br/>
            </remarks>
            <returns>
            
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">IConfiguration</see>
            the Configuration
            context for this ObjectContainer
            </returns>
            <seealso cref="M:Db4objects.Db4o.Db4oFactory.Configure">Db4objects.Db4o.Db4oFactory.Configure()
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Descend(System.Object,System.String[])">
            <summary>returns a member at the specific path without activating intermediate objects.
            	</summary>
            <remarks>
            returns a member at the specific path without activating intermediate objects.
            <br /><br />
            This method allows navigating from a persistent object to it's members in a
            performant way without activating or instantiating intermediate objects.
            </remarks>
            <param name="obj">the parent object that is to be used as the starting point.</param>
            <param name="path">an array of field names to navigate by</param>
            <returns>the object at the specified path or null if no object is found</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetByID(System.Int64)">
            <summary>returns the stored object for an internal ID.</summary>
            <remarks>
            returns the stored object for an internal ID.
            <br/><br/>This is the fastest method for direct access to objects. Internal
            IDs can be obtained with
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetID(System.Object)">getID(Object)</see>
            .
            Objects will not be activated by this method. They will be returned in the
            activation state they are currently in, in the local cache.<br/><br/>
            Passing invalid id values to this method may result in all kinds of
            exceptions being thrown. OutOfMemoryError and arithmetic exceptions
            may occur. If an application is known to use invalid IDs, it is
            recommended to call this method within a catch-all block.
            </remarks>
            <param name="Id">the internal ID</param>
            <returns>
            the object associated with the passed ID or <code>null</code>,
            if no object is associated with this ID in this <code>ObjectContainer</code>.
            </returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?
            	</seealso>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException">
            when the provided id is outside the scope of the
            file length.
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetByUUID(Db4objects.Db4o.Ext.Db4oUUID)">
            <summary>
            returns a stored object for a
            <see cref="T:Db4objects.Db4o.Ext.Db4oUUID">Db4oUUID</see>
            .
            <br/><br/>
            This method is intended for replication and for long-term
            external references to objects. To get a
            <see cref="T:Db4objects.Db4o.Ext.Db4oUUID">Db4oUUID</see>
            for an
            object use
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetObjectInfo(System.Object)">GetObjectInfo(object)</see>
            and
            <see cref="M:Db4objects.Db4o.Ext.IObjectInfo.GetUUID">IObjectInfo.GetUUID()</see>
            .<br/><br/>
            Objects will not be activated by this method. They will be returned in the
            activation state they are currently in, in the local cache.<br/><br/>
            </summary>
            <param name="uuid">the UUID</param>
            <returns>the object for the UUID</returns>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">Why activation?
            	</seealso>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">I/O operation failed or was unexpectedly interrupted.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetID(System.Object)">
            <summary>returns the internal unique object ID.</summary>
            <remarks>
            returns the internal unique object ID.
            <br/><br/>db4o assigns an internal ID to every object that is stored. IDs are
            guaranteed to be unique within one <code>ObjectContainer</code>.
            An object carries the same ID in every db4o session. Internal IDs can
            be used to look up objects with the very fast
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetByID(System.Int64)">getByID</see>
            method.<br/><br/>
            Internal IDs will change when a database is defragmented. Use
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetObjectInfo(System.Object)">GetObjectInfo(object)</see>
            ,
            <see cref="M:Db4objects.Db4o.Ext.IObjectInfo.GetUUID">IObjectInfo.GetUUID()</see>
            and
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetByUUID(Db4objects.Db4o.Ext.Db4oUUID)">GetByUUID(Db4oUUID)</see>
            for long-term external references to
            objects.<br/><br/>
            </remarks>
            <param name="obj">any object</param>
            <returns>
            the associated internal ID or <code>0</code>, if the passed
            object is not stored in this <code>ObjectContainer</code>.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetObjectInfo(System.Object)">
            <summary>
            returns the
            <see cref="T:Db4objects.Db4o.Ext.IObjectInfo">IObjectInfo</see>
            for a stored object.
            <br/><br/>This method will return null, if the passed
            object is not stored to this <code>ObjectContainer</code>.<br/><br/>
            </summary>
            <param name="obj">the stored object</param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.Ext.IObjectInfo">IObjectInfo</see>
            
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Identity">
            <summary>returns the Db4oDatabase object for this ObjectContainer.</summary>
            <remarks>returns the Db4oDatabase object for this ObjectContainer.</remarks>
            <returns>the Db4oDatabase identity object for this ObjectContainer.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.IsActive(System.Object)">
            <summary>tests if an object is activated.</summary>
            <remarks>
            tests if an object is activated.
            <br /><br /><code>isActive</code> returns <code>false</code> if an object is not
            stored within the <code>ObjectContainer</code>.<br /><br />
            </remarks>
            <param name="obj">to be tested<br /><br /></param>
            <returns><code>true</code> if the passed object is active.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.IsCached(System.Int64)">
            <summary>tests if an object with this ID is currently cached.</summary>
            <remarks>
            tests if an object with this ID is currently cached.
            <br /><br />
            </remarks>
            <param name="Id">the internal ID</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.IsClosed">
            <summary>tests if this <code>ObjectContainer</code> is closed.</summary>
            <remarks>
            tests if this <code>ObjectContainer</code> is closed.
            <br /><br />
            </remarks>
            <returns><code>true</code> if this <code>ObjectContainer</code> is closed.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.IsStored(System.Object)">
            <summary>tests if an object is stored in this <code>ObjectContainer</code>.</summary>
            <remarks>
            tests if an object is stored in this <code>ObjectContainer</code>.
            <br/><br/>
            </remarks>
            <param name="obj">to be tested<br/><br/></param>
            <returns><code>true</code> if the passed object is stored.</returns>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.KnownClasses">
            <summary>
            returns all class representations that are known to this
            ObjectContainer because they have been used or stored.
            </summary>
            <remarks>
            returns all class representations that are known to this
            ObjectContainer because they have been used or stored.
            </remarks>
            <returns>
            all class representations that are known to this
            ObjectContainer because they have been used or stored.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Lock">
            <summary>returns the main synchronization lock.</summary>
            <remarks>
            returns the main synchronization lock.
            <br /><br />
            Synchronize over this object to ensure exclusive access to
            the ObjectContainer.<br /><br />
            Handle the use of this functionality with extreme care,
            since deadlocks can be produced with just two lines of code.
            </remarks>
            <returns>Object the ObjectContainer lock object</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.PeekPersisted(System.Object,System.Int32,System.Boolean)">
            <summary>
            returns a transient copy of a persistent object with all members set
            to the values that are currently stored to the database.
            </summary>
            <remarks>
            returns a transient copy of a persistent object with all members set
            to the values that are currently stored to the database.
            <br/><br/>
            The returned objects have no connection to the database.<br/><br/>
            With the <code>committed</code> parameter it is possible to specify,
            whether the desired object should contain the committed values or the
            values that were set by the running transaction with
            <see cref="M:Db4objects.Db4o.IObjectContainer.Store(System.Object)">Db4objects.Db4o.IObjectContainer.Store(object)
            	</see>
            .
            <br/><br/>A possible use case for this feature:<br/>
            An application might want to check all changes applied to an object
            by the running transaction.<br/><br/>
            </remarks>
            <param name="object">the object that is to be cloned</param>
            <param name="depth">the member depth to which the object is to be instantiated</param>
            <param name="committed">whether committed or set values are to be returned</param>
            <returns>the object</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Purge">
            <summary>unloads all clean indices from memory and frees unused objects.</summary>
            <remarks>
            unloads all clean indices from memory and frees unused objects.
            <br /><br />Call commit() and purge() consecutively to achieve the best
            result possible. This method can have a negative impact
            on performance since indices will have to be reread before further
            inserts, updates or queries can take place.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Purge(System.Object)">
            <summary>unloads a specific object from the db4o reference mechanism.</summary>
            <remarks>
            unloads a specific object from the db4o reference mechanism.
            <br /><br />db4o keeps references to all newly stored and
            instantiated objects in memory, to be able to manage object identities.
            <br /><br />With calls to this method it is possible to remove an object from the
            reference mechanism, to allow it to be garbage collected. You are not required to
            call this method in the .NET and JDK 1.2 versions, since objects are
            referred to by weak references and garbage collection happens
            automatically.<br /><br />An object removed with  <code>purge(Object)</code> is not
            "known" to the <code>ObjectContainer</code> afterwards, so this method may also be
            used to create multiple copies of  objects.<br /><br /> <code>purge(Object)</code> has
            no influence on the persistence state of objects. "Purged" objects can be
            reretrieved with queries.<br /><br />
            </remarks>
            <param name="obj">the object to be removed from the reference mechanism.</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Reflector">
            <summary>Return the reflector currently being used by db4objects.</summary>
            <remarks>Return the reflector currently being used by db4objects.</remarks>
            <returns>the current Reflector.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Refresh(System.Object,System.Int32)">
            <summary>refreshs all members on a stored object to the specified depth.</summary>
            <remarks>
            refreshs all members on a stored object to the specified depth.
            <br/><br/>If a member object is not activated, it will be activated by this method.
            <br/><br/>The isolation used is READ COMMITTED. This method will read all objects
            and values that have been committed by other transactions.<br/><br/>
            </remarks>
            <param name="obj">the object to be refreshed.</param>
            <param name="depth">
            the member
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth(System.Int32)">depth</see>
            to which refresh is to cascade.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.ReleaseSemaphore(System.String)">
            <summary>releases a semaphore, if the calling transaction is the owner.</summary>
            <remarks>releases a semaphore, if the calling transaction is the owner.</remarks>
            <param name="name">the name of the semaphore to be released.</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.ReplicationBegin(Db4objects.Db4o.IObjectContainer,Db4objects.Db4o.Replication.IReplicationConflictHandler)">
            <param name="peerB">
            the
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            to replicate with.
            </param>
            <param name="conflictHandler">
            the conflict handler for this ReplicationProcess.
            Conflicts occur
            whenever
            <see cref="M:Db4objects.Db4o.Replication.IReplicationProcess.Replicate(System.Object)">Db4objects.Db4o.Replication.IReplicationProcess.Replicate(object)
            	</see>
            is called with an
            object that was modified in both ObjectContainers since the last
            replication run between the two. Upon a conflict the
            <see cref="M:Db4objects.Db4o.Replication.IReplicationConflictHandler.ResolveConflict(Db4objects.Db4o.Replication.IReplicationProcess,System.Object,System.Object)">Db4objects.Db4o.Replication.IReplicationConflictHandler.ResolveConflict(Db4objects.Db4o.Replication.IReplicationProcess, object, object)
            	</see>
            method will be called in the conflict handler.
            </param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.Replication.IReplicationProcess">Db4objects.Db4o.Replication.IReplicationProcess
            	</see>
            interface for this replication process.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Set(System.Object,System.Int32)">
            <summary>deep update interface to store or update objects.</summary>
            <remarks>
            deep update interface to store or update objects.
            <br/><br/>In addition to the normal storage interface,
            <see cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">ObjectContainer#set(Object)
            	</see>
            ,
            this method allows a manual specification of the depth, the passed object is to be updated.<br/><br/>
            </remarks>
            <param name="obj">the object to be stored or updated.</param>
            <param name="depth">the depth to which the object is to be updated</param>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">Db4objects.Db4o.IObjectContainer.Set(object)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Store(System.Object,System.Int32)">
            <summary>deep update interface to store or update objects.</summary>
            <remarks>
            deep update interface to store or update objects.
            <br/><br/>In addition to the normal storage interface,
            <see cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">ObjectContainer#set(Object)
            	</see>
            ,
            this method allows a manual specification of the depth, the passed object is to be updated.<br/><br/>
            </remarks>
            <param name="obj">the object to be stored or updated.</param>
            <param name="depth">the depth to which the object is to be updated</param>
            <seealso cref="M:Db4objects.Db4o.IObjectContainer.Set(System.Object)">Db4objects.Db4o.IObjectContainer.Set(object)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.SetSemaphore(System.String,System.Int32)">
            <summary>attempts to set a semaphore.</summary>
            <remarks>
            attempts to set a semaphore.
            <br/><br/>
            Semaphores are transient multi-purpose named flags for
            <see cref="T:Db4objects.Db4o.IObjectContainer">ObjectContainers</see>
            .
            <br/><br/>
            A transaction that successfully sets a semaphore becomes
            the owner of the semaphore. Semaphores can only be owned
            by a single transaction at one point in time.<br/><br/>
            This method returns true, if the transaction already owned
            the semaphore before the method call or if it successfully
            acquires ownership of the semaphore.<br/><br/>
            The waitForAvailability parameter allows to specify a time
            in milliseconds to wait for other transactions to release
            the semaphore, in case the semaphore is already owned by
            another transaction.<br/><br/>
            Semaphores are released by the first occurrence of one of the
            following:<br/>
            - the transaction releases the semaphore with
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.ReleaseSemaphore(System.String)">ReleaseSemaphore(string)</see>
            <br/> - the transaction is closed with
            <see cref="M:Db4objects.Db4o.IObjectContainer.Close">Db4objects.Db4o.IObjectContainer.Close()
            	</see>
            <br/> - C/S only: the corresponding
            <see cref="T:Db4objects.Db4o.IObjectServer">Db4objects.Db4o.IObjectServer</see>
            is
            closed.<br/> - C/S only: the client
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            looses the connection and is timed
            out.<br/><br/> Semaphores are set immediately. They are independant of calling
            <see cref="M:Db4objects.Db4o.IObjectContainer.Commit">Db4objects.Db4o.IObjectContainer.Commit()
            	</see>
            or
            <see cref="M:Db4objects.Db4o.IObjectContainer.Rollback">Db4objects.Db4o.IObjectContainer.Rollback()
            	</see>
            .<br/><br/> <b>Possible use cases
            for semaphores:</b><br/> - prevent other clients from inserting a singleton at the same time.
            A suggested name for the semaphore:  "SINGLETON_" + Object#getClass().getName().<br/>  - lock
            objects. A suggested name:   "LOCK_" +
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetID(System.Object)">getID(Object)</see>
            <br/> -
            generate a unique client ID. A suggested name:  "CLIENT_" +
            System.currentTimeMillis().<br/><br/>
            </remarks>
            <param name="name">the name of the semaphore to be set</param>
            <param name="waitForAvailability">
            the time in milliseconds to wait for other
            transactions to release the semaphore. The parameter may be zero, if
            the method is to return immediately.
            </param>
            <returns>
            boolean flag
            <br/><code>true</code>, if the semaphore could be set or if the
            calling transaction already owned the semaphore.
            <br/><code>false</code>, if the semaphore is owned by another
            transaction.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.StoredClass(System.Object)">
            <summary>
            returns a
            <see cref="T:Db4objects.Db4o.Ext.IStoredClass">IStoredClass</see>
            meta information object.
            <br/><br/>
            There are three options how to use this method.<br/>
            Any of the following parameters are possible:<br/>
            - a fully qualified class name.<br/>
            - a Class object.<br/>
            - any object to be used as a template.<br/><br/>
            </summary>
            <param name="clazz">class name, Class object, or example object.<br/><br/></param>
            <returns>
            an instance of an
            <see cref="T:Db4objects.Db4o.Ext.IStoredClass">IStoredClass</see>
            meta information object.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.StoredClasses">
            <summary>
            returns an array of all
            <see cref="T:Db4objects.Db4o.Ext.IStoredClass">IStoredClass</see>
            meta information objects.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.SystemInfo">
            <summary>
            returns the
            <see cref="T:Db4objects.Db4o.Ext.ISystemInfo">ISystemInfo</see>
            for this ObjectContainer.
            <br/><br/>The
            <see cref="T:Db4objects.Db4o.Ext.ISystemInfo">ISystemInfo</see>
            supplies methods that provide
            information about system state and system settings of this
            ObjectContainer.
            </summary>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.Ext.ISystemInfo">ISystemInfo</see>
            for this ObjectContainer.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectContainer.Version">
            <summary>returns the current transaction serial number.</summary>
            <remarks>
            returns the current transaction serial number.
            <br /><br />This serial number can be used to query for modified objects
            and for replication purposes.
            </remarks>
            <returns>the current transaction serial number.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtClient.SwitchToFile(System.String)">
            <summary>requests opening a different server database file for this client session.
            	</summary>
            <remarks>
            requests opening a different server database file for this client session.
            <br /><br />
            This method can be used to switch between database files from the client
            side while not having to open a new socket connection or closing the
            current one.
            <br /><br />
            If the database file does not exist on the server, it will be created.
            <br /><br />
            A typical usecase:<br />
            The main database file is used for login, user and rights management only.
            Only one single db4o server session needs to be run. Multiple satellite
            database files are used for different applications or multiple user circles.
            Storing the data to multiple database files has the following advantages:<br />
            - easier rights management<br />
            - easier backup<br />
            - possible later load balancing to multiple servers<br />
            - better performance of smaller individual database files<br />
            - special debugging database files can be used
            <br /><br />
            User authorization to the alternative database file will not be checked.
            <br /><br />
            All persistent references to objects that are currently in memory
            are discarded during the switching process.<br /><br />
            </remarks>
            <param name="fileName">the fully qualified path of the requested database file.</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtClient.SwitchToMainFile">
            <summary>
            requests switching back to the main database file after a previous call
            to <code>switchToFile(String fileName)</code>.
            </summary>
            <remarks>
            requests switching back to the main database file after a previous call
            to <code>switchToFile(String fileName)</code>.
            <br /><br />
            All persistent references to objects that are currently in memory
            are discarded during the switching process.<br /><br />
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtClient.IsAlive">
            <summary>checks if the client is currently connected to a server.</summary>
            <remarks>checks if the client is currently connected to a server.</remarks>
            <returns>true if the client is alive.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IExtObjectServer">
            <summary>extended functionality for the ObjectServer interface.</summary>
            <remarks>
            extended functionality for the ObjectServer interface.
            <br/><br/>Every ObjectServer also always is an ExtObjectServer
            so a cast is possible.<br/><br/>
            <see cref="M:Db4objects.Db4o.IObjectServer.Ext">Db4objects.Db4o.IObjectServer.Ext()
            	</see>
            is a convenient method to perform the cast.<br/><br/>
            The functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.IObjectServer">
            <summary>the db4o server interface.</summary>
            <remarks>
            the db4o server interface.
            <br/><br/>- db4o servers can be opened with
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">Db4oFactory.OpenServer(string, int)
            	</see>
            .<br/>
            - Direct in-memory connections to servers can be made with
            <see cref="M:Db4objects.Db4o.IObjectServer.OpenClient">OpenClient()</see>
            <br/>
            - TCP connections are available through
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenClient(System.String,System.Int32,System.String,System.String)">Db4oFactory.OpenClient(string, int, string, string)
            	</see>
            .
            <br/><br/>Before connecting clients over TCP, you have to
            <see cref="M:Db4objects.Db4o.IObjectServer.GrantAccess(System.String,System.String)">GrantAccess(string, string)</see>
            to the username and password combination
            that you want to use.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Db4oFactory.OpenServer(System.String,System.Int32)">Db4o.openServer</seealso>
            <seealso cref="T:Db4objects.Db4o.Ext.IExtObjectServer">ExtObjectServer for extended functionality
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IObjectServer.Close">
            <summary>
            closes the
            <see cref="T:Db4objects.Db4o.IObjectServer"></see>
            and writes all cached data.
            <br/><br/>
            </summary>
            <returns>
            true - denotes that the last instance connected to the
            used database file was closed.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectServer.Ext">
            <summary>
            returns an
            <see cref="T:Db4objects.Db4o.IObjectServer"></see>
            with extended functionality.
            <br/><br/>Use this method as a convenient accessor to extended methods.
            Every
            <see cref="T:Db4objects.Db4o.IObjectServer"></see>
            can be casted to an
            <see cref="T:Db4objects.Db4o.Ext.IExtObjectServer">Db4objects.Db4o.Ext.IExtObjectServer
            	</see>
            .
            <br/><br/>The functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.IObjectServer.GrantAccess(System.String,System.String)">
            <summary>grants client access to the specified user with the specified password.</summary>
            <remarks>
            grants client access to the specified user with the specified password.
            <br /><br />If the user already exists, the password is changed to
            the specified password.<br /><br />
            </remarks>
            <param name="userName">the name of the user</param>
            <param name="password">the password to be used</param>
        </member>
        <member name="M:Db4objects.Db4o.IObjectServer.OpenClient">
            <summary>opens a client against this server.</summary>
            <remarks>
            opens a client against this server.
            <br/><br/>A client opened with this method operates within the same VM
            as the server. Since an embedded client can use direct communication, without
            an in-between socket connection, performance will be better than a client
            opened with
            <see cref="M:Db4objects.Db4o.Db4oFactory.OpenClient(System.String,System.Int32,System.String,System.String)">Db4oFactory.OpenClient(string, int, string, string)
            	</see>
            <br/><br/>Every client has it's own transaction and uses it's own cache
            for it's own version of all peristent objects.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectServer.Backup(System.String)">
            <summary>backs up the database file used by the ObjectServer.</summary>
            <remarks>
            backs up the database file used by the ObjectServer.
            <br/><br/>While the backup is running, the ObjectServer can continue to be
            used. Changes that are made while the backup is in progress, will be applied to
            the open ObjectServer and to the backup.<br/><br/>
            While the backup is running, the ObjectContainer should not be closed.<br/><br/>
            If a file already exists at the specified path, it will be overwritten.<br/><br/>
            </remarks>
            <param name="path">a fully qualified path</param>
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectServer.ClientCount">
            <summary>returns the number of connected clients.</summary>
            <remarks>returns the number of connected clients.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectServer.Configure">
            <summary>
            returns the
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">Db4objects.Db4o.Config.IConfiguration
            	</see>
            context for this ObjectServer.
            <br/><br/>
            Upon opening an ObjectServer with any of the factory methods in the
            <see cref="T:Db4objects.Db4o.Db4oFactory">Db4objects.Db4o.Db4oFactory</see>
            class, the global
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">Db4objects.Db4o.Config.IConfiguration
            	</see>
            context
            is copied into the ObjectServer. The
            <see cref="T:Db4objects.Db4o.Config.IConfiguration">Db4objects.Db4o.Config.IConfiguration
            	</see>
            can be modified individually for
            each ObjectServer without any effects on the global settings.<br/><br/>
            </summary>
            <returns>the Configuration context for this ObjectServer</returns>
            <seealso cref="M:Db4objects.Db4o.Db4oFactory.Configure">Db4objects.Db4o.Db4oFactory.Configure()
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectServer.ObjectContainer">
            <summary>returns the ObjectContainer used by the server.</summary>
            <remarks>
            returns the ObjectContainer used by the server.
            <br /><br />
            </remarks>
            <returns>the ObjectContainer used by the server</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectServer.RevokeAccess(System.String)">
            <summary>removes client access permissions for the specified user.</summary>
            <remarks>
            removes client access permissions for the specified user.
            <br /><br />
            </remarks>
            <param name="userName">the name of the user</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectServer.Port">
            <returns>The local port this server uses, 0 if disconnected or in embedded mode</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IExtObjectSet">
            <summary>
            extended functionality for the
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            interface.
            <br/><br/>Every db4o
            <see cref="T:Db4objects.Db4o.IObjectSet">IObjectSet</see>
            always is an ExtObjectSet so a cast is possible.<br/><br/>
            <see cref="M:Db4objects.Db4o.IObjectSet.Ext">Db4objects.Db4o.IObjectSet.Ext()</see>
            is a convenient method to perform the cast.<br/><br/>
            The ObjectSet functionality is split to two interfaces to allow newcomers to
            focus on the essential methods.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.IObjectSet">
            <summary>query resultset.</summary>
            <remarks>
            query resultset.
            <br/><br/>An ObjectSet is a representation for a set of objects returned
            by a query.
            <br/><br/>ObjectSet extends the system collection interfaces
            java.util.List/System.Collections.IList where they are available. It is
            recommended, never to reference ObjectSet directly in code but to use
            List / IList instead.
            <br/><br/>Note that the underlying
            <see cref="T:Db4objects.Db4o.IObjectContainer">IObjectContainer</see>
            of an ObjectSet
            needs to remain open as long as an ObjectSet is used. This is necessary
            for lazy instantiation. The objects in an ObjectSet are only instantiated
            when they are actually being used by the application.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Ext.IExtObjectSet">for extended functionality.</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IObjectSet.Ext">
            <summary>returns an ObjectSet with extended functionality.</summary>
            <remarks>
            returns an ObjectSet with extended functionality.
            <br /><br />Every ObjectSet that db4o provides can be casted to
            an ExtObjectSet. This method is supplied for your convenience
            to work without a cast.
            <br /><br />The ObjectSet functionality is split to two interfaces
            to allow newcomers to focus on the essential methods.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IObjectSet.HasNext">
            <summary>returns <code>true</code> if the <code>ObjectSet</code> has more elements.
            	</summary>
            <remarks>returns <code>true</code> if the <code>ObjectSet</code> has more elements.
            	</remarks>
            <returns>
            boolean - <code>true</code> if the <code>ObjectSet</code> has more
            elements.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectSet.Next">
            <summary>returns the next object in the <code>ObjectSet</code>.</summary>
            <remarks>
            returns the next object in the <code>ObjectSet</code>.
            <br/><br/>
            Before returning the Object, next() triggers automatic activation of the
            Object with the respective
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.ActivationDepth">global</see>
            or
            <see cref="M:Db4objects.Db4o.Config.IObjectClass.MaximumActivationDepth(System.Int32)">class specific
            	</see>
            setting.<br/><br/>
            </remarks>
            <returns>the next object in the <code>ObjectSet</code>.</returns>
        </member>
        <member name="M:Db4objects.Db4o.IObjectSet.Reset">
            <summary>resets the <code>ObjectSet</code> cursor before the first element.</summary>
            <remarks>
            resets the <code>ObjectSet</code> cursor before the first element.
            <br /><br />A subsequent call to <code>next()</code> will return the first element.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectSet.GetIDs">
            <summary>returns an array of internal IDs that correspond to the contained objects.
            	</summary>
            <remarks>
            returns an array of internal IDs that correspond to the contained objects.
            <br/><br/>
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetID(System.Object)">IExtObjectContainer.GetID(object)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetByID(System.Int64)">IExtObjectContainer.GetByID(long)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IExtObjectSet.Get(System.Int32)">
            <summary>returns the item at position [index] in this ObjectSet.</summary>
            <remarks>
            returns the item at position [index] in this ObjectSet.
            <br /><br />
            The object will be activated.
            </remarks>
            <param name="index">the index position in this ObjectSet.</param>
            <returns>the activated object.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IObjectCallbacks">
            <summary>callback methods.</summary>
            <remarks>
            callback methods.
            <br /><br />
            This interface only serves as a list of all available callback methods.
            Every method is called individually, independantly of implementing this interface.<br /><br />
            <b>Using callbacks</b><br />
            Simply implement one or more of the listed methods in your application classes to
            do tasks before activation, deactivation, delete, new or update, to cancel the
            action about to be performed and to respond to the performed task.
            <br /><br />Callback methods are typically used for:
            <br />- cascaded delete
            <br />- cascaded update
            <br />- cascaded activation
            <br />- restoring transient members on instantiation
            <br /><br />Callback methods follow regular calling conventions. Methods in superclasses
            need to be called explicitely.
            <br /><br />All method calls are implemented to occur only once, upon one event.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectCanActivate(Db4objects.Db4o.IObjectContainer)">
            <summary>called before an Object is activated.</summary>
            <remarks>called before an Object is activated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent activation.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectCanDeactivate(Db4objects.Db4o.IObjectContainer)">
            <summary>called before an Object is deactivated.</summary>
            <remarks>called before an Object is deactivated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent deactivation.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectCanDelete(Db4objects.Db4o.IObjectContainer)">
            <summary>called before an Object is deleted.</summary>
            <remarks>
            called before an Object is deleted.
            <br /><br />In a client/server setup this callback method will be executed on
            the server.
            </remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent the object from being deleted.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectCanNew(Db4objects.Db4o.IObjectContainer)">
            <summary>called before an Object is stored the first time.</summary>
            <remarks>called before an Object is stored the first time.</remarks>
            <param name="container">the <code>ObjectContainer</code> is about to be stored to.
            	</param>
            <returns>false to prevent the object from being stored.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectCanUpdate(Db4objects.Db4o.IObjectContainer)">
            <summary>called before a persisted Object is updated.</summary>
            <remarks>called before a persisted Object is updated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
            <returns>false to prevent the object from being updated.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectOnActivate(Db4objects.Db4o.IObjectContainer)">
            <summary>called upon activation of an object.</summary>
            <remarks>called upon activation of an object.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectOnDeactivate(Db4objects.Db4o.IObjectContainer)">
            <summary>called upon deactivation of an object.</summary>
            <remarks>called upon deactivation of an object.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectOnDelete(Db4objects.Db4o.IObjectContainer)">
            <summary>called after an object was deleted.</summary>
            <remarks>
            called after an object was deleted.
            <br /><br />In a client/server setup this callback method will be executed on
            the server.
            </remarks>
            <param name="container">the <code>ObjectContainer</code> the object was stored in.
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectOnNew(Db4objects.Db4o.IObjectContainer)">
            <summary>called after a new object was stored.</summary>
            <remarks>called after a new object was stored.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored to.
            	</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectCallbacks.ObjectOnUpdate(Db4objects.Db4o.IObjectContainer)">
            <summary>called after an object was updated.</summary>
            <remarks>called after an object was updated.</remarks>
            <param name="container">the <code>ObjectContainer</code> the object is stored in.
            	</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IObjectInfo">
            <summary>
            interface to the internal reference that an ObjectContainer
            holds for a stored object.
            </summary>
            <remarks>
            interface to the internal reference that an ObjectContainer
            holds for a stored object.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectInfo.GetInternalID">
            <summary>returns the internal db4o ID.</summary>
            <remarks>returns the internal db4o ID.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectInfo.GetObject">
            <summary>returns the object that is referenced.</summary>
            <remarks>
            returns the object that is referenced.
            <br /><br />This method may return null, if the object has
            been garbage collected.
            </remarks>
            <returns>
            the referenced object or null, if the object has
            been garbage collected.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectInfo.GetUUID">
            <summary>returns a UUID representation of the referenced object.</summary>
            <remarks>
            returns a UUID representation of the referenced object.
            UUID generation has to be turned on, in order to be able
            to use this feature:
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.GenerateUUIDs(System.Int32)">Db4objects.Db4o.Config.IConfiguration.GenerateUUIDs(int)
            	</see>
            </remarks>
            <returns>the UUID of the referenced object.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IObjectInfo.GetVersion">
            <summary>
            returns the transaction serial number ("version") the
            referenced object was stored with last.
            </summary>
            <remarks>
            returns the transaction serial number ("version") the
            referenced object was stored with last.
            Version number generation has to be turned on, in order to
            be able to use this feature:
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.GenerateVersionNumbers(System.Int32)">Db4objects.Db4o.Config.IConfiguration.GenerateVersionNumbers(int)
            	</see>
            </remarks>
            <returns>the version number.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IObjectInfoCollection">
            <summary>
            Interface to an iterable collection
            <see cref="T:Db4objects.Db4o.Ext.IObjectInfo">IObjectInfo</see>
            objects.<br/><br/>
            ObjectInfoCollection is used reference a number of stored objects.
            </summary>
            <seealso cref="T:Db4objects.Db4o.Ext.IObjectInfo">IObjectInfo</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IStoredClass">
            <summary>the internal representation of a stored class.</summary>
            <remarks>the internal representation of a stored class.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.GetName">
            <summary>returns the name of this stored class.</summary>
            <remarks>returns the name of this stored class.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.GetIDs">
            <summary>returns an array of IDs of all stored object instances of this stored class.
            	</summary>
            <remarks>returns an array of IDs of all stored object instances of this stored class.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.GetParentStoredClass">
            <summary>returns the StoredClass for the parent of the class, this StoredClass represents.
            	</summary>
            <remarks>returns the StoredClass for the parent of the class, this StoredClass represents.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.GetStoredFields">
            <summary>returns all stored fields of this stored class.</summary>
            <remarks>returns all stored fields of this stored class.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.HasClassIndex">
            <summary>returns true if this StoredClass has a class index.</summary>
            <remarks>returns true if this StoredClass has a class index.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.Rename(System.String)">
            <summary>renames this stored class.</summary>
            <remarks>
            renames this stored class.
            <br /><br />After renaming one or multiple classes the ObjectContainer has
            to be closed and reopened to allow internal caches to be refreshed.
            <br /><br />.NET: As the name you should provide [Classname, Assemblyname]<br /><br />
            </remarks>
            <param name="name">the new name</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.StoredField(System.String,System.Object)">
            <summary>returns an existing stored field of this stored class.</summary>
            <remarks>returns an existing stored field of this stored class.</remarks>
            <param name="name">the name of the field</param>
            <param name="type">
            the type of the field.
            There are four possibilities how to supply the type:<br/>
            - a Class object.  (.NET: a Type object)<br/>
            - a fully qualified classname.<br/>
            - any object to be used as a template.<br/><br/>
            - null, if the first found field should be returned.
            </param>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.Ext.IStoredField">IStoredField</see>
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredClass.InstanceCount">
            <summary>
            Returns the number of instances of this class that have been persisted to the
            database, as seen by the transaction (container) that produces this StoredClass
            instance.
            </summary>
            <remarks>
            Returns the number of instances of this class that have been persisted to the
            database, as seen by the transaction (container) that produces this StoredClass
            instance.
            </remarks>
            <returns>The number of instances</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IStoredField">
            <summary>the internal representation of a field on a stored class.</summary>
            <remarks>the internal representation of a field on a stored class.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.CreateIndex">
            <summary>creates an index on this field at runtime.</summary>
            <remarks>creates an index on this field at runtime.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.DropIndex">
            <summary>drops an existing index on this field at runtime.</summary>
            <remarks>drops an existing index on this field at runtime.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.Get(System.Object)">
            <summary>returns the field value on the passed object.</summary>
            <remarks>
            returns the field value on the passed object.
            <br /><br />This method will also work, if the field is not present in the current
            version of the class.
            <br /><br />It is recommended to use this method for refactoring purposes, if fields
            are removed and the field values need to be copied to other fields.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.GetName">
            <summary>returns the name of the field.</summary>
            <remarks>returns the name of the field.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.GetStoredType">
            <summary>returns the Class (Java) / Type (.NET) of the field.</summary>
            <remarks>
            returns the Class (Java) / Type (.NET) of the field.
            <br/><br/>For array fields this method will return the type of the array.
            Use
            <see cref="M:Db4objects.Db4o.Ext.IStoredField.IsArray">IsArray()</see>
            to detect arrays.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.IsArray">
            <summary>returns true if the field is an array.</summary>
            <remarks>returns true if the field is an array.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.Rename(System.String)">
            <summary>modifies the name of this stored field.</summary>
            <remarks>
            modifies the name of this stored field.
            <br /><br />After renaming one or multiple fields the ObjectContainer has
            to be closed and reopened to allow internal caches to be refreshed.<br /><br />
            </remarks>
            <param name="name">the new name</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.TraverseValues(Db4objects.Db4o.Foundation.IVisitor4)">
            <summary>
            specialized highspeed API to collect all values of a field for all instances
            of a class, if the field is indexed.
            </summary>
            <remarks>
            specialized highspeed API to collect all values of a field for all instances
            of a class, if the field is indexed.
            <br /><br />The field values will be taken directly from the index without the
            detour through class indexes or object instantiation.
            <br /><br />
            If this method is used to get the values of a first class object index,
            deactivated objects will be passed to the visitor.
            </remarks>
            <param name="visitor">the visitor to be called with each index value.</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.IStoredField.HasIndex">
            <summary>Returns whether this field has an index or not.</summary>
            <remarks>Returns whether this field has an index or not.</remarks>
            <returns>true if this field has an index.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.ISystemInfo">
            <summary>provides information about system state and system settings.</summary>
            <remarks>provides information about system state and system settings.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.ISystemInfo.FreespaceEntryCount">
            <summary>returns the number of entries in the Freespace Manager.</summary>
            <remarks>
            returns the number of entries in the Freespace Manager.
            <br /><br />A high value for the number of freespace entries
            is an indication that the database is fragmented and
            that defragment should be run.
            </remarks>
            <returns>the number of entries in the Freespace Manager.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.ISystemInfo.FreespaceSize">
            <summary>returns the freespace size in the database in bytes.</summary>
            <remarks>
            returns the freespace size in the database in bytes.
            <br /><br />When db4o stores modified objects, it allocates
            a new slot for it. During commit the old slot is freed.
            Free slots are collected in the freespace manager, so
            they can be reused for other objects.
            <br /><br />This method returns a sum of the size of all
            free slots in the database file.
            <br /><br />To reclaim freespace run defragment.
            </remarks>
            <returns>the freespace size in the database in bytes.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.ISystemInfo.TotalSize">
            <summary>Returns the total size of the database on disk.</summary>
            <remarks>Returns the total size of the database on disk.</remarks>
            <returns>total size of database on disk</returns>
        </member>
        <member name="T:Db4objects.Db4o.Ext.IncompatibleFileFormatException">
            <summary>
            db4o-specific exception.<br /><br />
            This exception is thrown when the database file format
            is not compatible with the applied configuration.
            </summary>
            <remarks>
            db4o-specific exception.<br /><br />
            This exception is thrown when the database file format
            is not compatible with the applied configuration.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.InvalidIDException">
            <summary>
            db4o-specific exception.<br/><br/>
            This exception is thrown when the supplied object ID
            is incorrect (outside the scope of the database IDs).
            </summary>
            <remarks>
            db4o-specific exception.<br/><br/>
            This exception is thrown when the supplied object ID
            is incorrect (outside the scope of the database IDs).
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Bind(System.Object,System.Int64)">IExtObjectContainer.Bind(object, long)
            	</seealso>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.GetByID(System.Int64)">IExtObjectContainer.GetByID(long)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.InvalidIDException.#ctor(System.Exception)">
            <summary>Constructor allowing to specify the exception cause</summary>
            <param name="cause">cause exception</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.InvalidIDException.#ctor(System.Int32)">
            <summary>Constructor allowing to specify the offending id</summary>
            <param name="id">the offending id</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.InvalidPasswordException">
            <summary>
            db4o-specific exception.<br /><br />
            This exception is thrown when a client tries to connect
            to a server with a wrong password or null password.
            </summary>
            <remarks>
            db4o-specific exception.<br /><br />
            This exception is thrown when a client tries to connect
            to a server with a wrong password or null password.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.InvalidSlotException">
            <summary>
            db4o-specific exception.<br /><br />
            This exception is thrown when db4o reads slot
            information which is not valid (length or address).
            </summary>
            <remarks>
            db4o-specific exception.<br /><br />
            This exception is thrown when db4o reads slot
            information which is not valid (length or address).
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Ext.InvalidSlotException.#ctor(System.String)">
            <summary>Constructor allowing to specify a detailed message.</summary>
            <remarks>Constructor allowing to specify a detailed message.</remarks>
            <param name="msg">message</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.InvalidSlotException.#ctor(System.Int32,System.Int32,System.Int32)">
            <summary>Constructor allowing to specify the address, length and id.</summary>
            <remarks>Constructor allowing to specify the address, length and id.</remarks>
            <param name="address">offending address</param>
            <param name="length">offending length</param>
            <param name="id">id where the address and length were read.</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.MemoryFile">
            <summary>carries in-memory data for db4o in-memory operation.</summary>
            <remarks>
            carries in-memory data for db4o in-memory operation.
            <br/><br/>In-memory ObjectContainers are useful for maximum performance
            on small databases, for swapping objects or for storing db4o format data
            to other media or other databases.<br/><br/>Be aware of the danger of running
            into OutOfMemory problems or complete loss of all data, in case of hardware
            or runtime failures.
            <br/><br/>
            
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">ExtDb4oFactory.OpenMemoryFile</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.#ctor">
            <summary>constructs a new MemoryFile without any data.</summary>
            <remarks>constructs a new MemoryFile without any data.</remarks>
            <seealso cref="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">ExtDb4oFactory.OpenMemoryFile(MemoryFile)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.#ctor(System.Byte[])">
            <summary>
            constructs a MemoryFile to use the byte data from a previous
            MemoryFile.
            </summary>
            <remarks>
            constructs a MemoryFile to use the byte data from a previous
            MemoryFile.
            </remarks>
            <param name="bytes">the raw byte data.</param>
            <seealso cref="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">ExtDb4oFactory.OpenMemoryFile(MemoryFile)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.GetBytes">
            <summary>returns the raw byte data.</summary>
            <remarks>
            returns the raw byte data.
            <br /><br />Use this method to get the byte data from the MemoryFile
            to store it to other media or databases, for backup purposes or
            to create other MemoryFile sessions.
            <br /><br />The byte data from a MemoryFile should only be used
            after it is closed.<br /><br />
            </remarks>
            <returns>bytes the raw byte data.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.GetIncrementSizeBy">
            <summary>
            returns the size the MemoryFile is to be enlarged, if it grows beyond
            the current size.
            </summary>
            <remarks>
            returns the size the MemoryFile is to be enlarged, if it grows beyond
            the current size.
            </remarks>
            <returns>size in bytes</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.GetInitialSize">
            <summary>returns the initial size of the MemoryFile.</summary>
            <remarks>returns the initial size of the MemoryFile.</remarks>
            <returns>size in bytes</returns>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.SetBytes(System.Byte[])">
            <summary>sets the raw byte data.</summary>
            <remarks>
            sets the raw byte data.
            <br /><br /><b>Caution!</b><br />Calling this method during a running
            Memory File session may produce unpreditable results.
            </remarks>
            <param name="bytes">the raw byte data.</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.SetIncrementSizeBy(System.Int32)">
            <summary>
            configures the size the MemoryFile is to be enlarged by, if it grows
            beyond the current size.
            </summary>
            <remarks>
            configures the size the MemoryFile is to be enlarged by, if it grows
            beyond the current size.
            <br/><br/>Call this method before passing the MemoryFile to
            <see cref="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">ExtDb4oFactory.OpenMemoryFile(MemoryFile)
            	</see>
            .
            <br/><br/>
            This parameter can be modified to tune the maximum performance of
            a MemoryFile for a specific usecase. To produce the best results,
            test the speed of your application with real data.<br/><br/>
            </remarks>
            <param name="byteCount">the desired size in bytes</param>
        </member>
        <member name="M:Db4objects.Db4o.Ext.MemoryFile.SetInitialSize(System.Int32)">
            <summary>configures the initial size of the MemoryFile.</summary>
            <remarks>
            configures the initial size of the MemoryFile.
            <br/><br/>Call this method before passing the MemoryFile to
            <see cref="M:Db4objects.Db4o.Ext.ExtDb4oFactory.OpenMemoryFile(Db4objects.Db4o.Ext.MemoryFile)">ExtDb4oFactory.OpenMemoryFile(MemoryFile)
            	</see>
            .
            <br/><br/>
            This parameter can be modified to tune the maximum performance of
            a MemoryFile for a specific usecase. To produce the best results,
            test speed and memory consumption of your application with
            real data.<br/><br/>
            </remarks>
            <param name="byteCount">the desired size in bytes</param>
        </member>
        <member name="T:Db4objects.Db4o.Ext.ObjectNotStorableException">
            <summary>
            this Exception is thrown, if objects can not be stored and if
            db4o is configured to throw Exceptions on storage failures.
            </summary>
            <remarks>
            this Exception is thrown, if objects can not be stored and if
            db4o is configured to throw Exceptions on storage failures.
            </remarks>
            <seealso cref="M:Db4objects.Db4o.Config.IConfiguration.ExceptionsOnNotStorable(System.Boolean)">Db4objects.Db4o.Config.IConfiguration.ExceptionsOnNotStorable(bool)</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Ext.OldFormatException">
            <summary>
            db4o-specific exception.<br/><br/>
            This exception is thrown when an old file format was detected
            and
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(System.Boolean)">Db4objects.Db4o.Config.IConfiguration.AllowVersionUpdates(bool)
            	</see>
            is set to false.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Ext.OldFormatException.#ctor">
            <summary>Constructor with the default message.</summary>
            <remarks>Constructor with the default message.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.Status">
            <summary>Static constants to describe the status of objects.</summary>
            <remarks>Static constants to describe the status of objects.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.UnsupportedOldFormatException">
            <summary>
            This exception is thrown while reading old database
            files for which support has been dropped.
            </summary>
            <remarks>
            This exception is thrown while reading old database
            files for which support has been dropped.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Ext.VirtualField">
            <summary>intended for future virtual fields on classes.</summary>
            <remarks>
            intended for future virtual fields on classes. Currently only
            the constant for the virtual version field is found here.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Ext.VirtualField.Version">
            <summary>
            the field name of the virtual version field, to be used
            for querying.
            </summary>
            <remarks>
            the field name of the virtual version field, to be used
            for querying.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.AbstractTreeIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Algorithms4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IndexedIterator">
            <summary>
            Basic functionality for implementing iterators for
            fixed length structures whose elements can be efficiently
            accessed by a numeric index.
            </summary>
            <remarks>
            Basic functionality for implementing iterators for
            fixed length structures whose elements can be efficiently
            accessed by a numeric index.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Arrays4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.BitMap4">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.BitMap4.#ctor(System.Byte[],System.Int32,System.Int32)">
            <summary>"readFrom  buffer" constructor</summary>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.BlockingQueue">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.IQueue4.NextMatching(Db4objects.Db4o.Foundation.IPredicate4)">
            <summary>Returns the next object in the queue that matches the specified condition.
            	</summary>
            <remarks>
            Returns the next object in the queue that matches the specified condition.
            The operation is always NON-BLOCKING.
            </remarks>
            <param name="condition">the object must satisfy to be returned</param>
            <returns>the object satisfying the condition or null if none does</returns>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.BlockingQueue.Next">
            <exception cref="T:Db4objects.Db4o.Foundation.BlockingQueueStoppedException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.BlockingQueueStoppedException">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.BooleanByRef">
            <summary>Useful as "out" or "by ref" function parameter.</summary>
            <remarks>Useful as "out" or "by ref" function parameter.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.ByRef">
            <summary>Useful as "out" or "by reference" function parameter.</summary>
            <remarks>Useful as "out" or "by reference" function parameter.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.CircularBuffer4">
            <summary>A fixed size double ended queue with O(1) complexity for addFirst, removeFirst and removeLast operations.
            	</summary>
            <remarks>A fixed size double ended queue with O(1) complexity for addFirst, removeFirst and removeLast operations.
            	</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.CircularIntBuffer4">
            <summary>A fixed size double ended queue with O(1) complexity for addFirst, removeFirst and removeLast operations.
            	</summary>
            <remarks>A fixed size double ended queue with O(1) complexity for addFirst, removeFirst and removeLast operations.
            	</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.CircularLongBuffer4">
            <summary>A fixed size double ended queue with O(1) complexity for addFirst, removeFirst and removeLast operations.
            	</summary>
            <remarks>A fixed size double ended queue with O(1) complexity for addFirst, removeFirst and removeLast operations.
            	</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Collection4">
            <summary>Fast linked list for all usecases.</summary>
            <remarks>Fast linked list for all usecases.</remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.ISequence4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IDeepClone">
            <summary>Deep clone</summary>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.IDeepClone.DeepClone(System.Object)">
            <summary>
            The parameter allows passing one new object so parent
            references can be corrected on children.
            </summary>
            <remarks>
            The parameter allows passing one new object so parent
            references can be corrected on children.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Types.IUnversioned">
            <summary>
            marker interface to denote that version numbers and UUIDs should
            not be generated for a class that implements this interface
            </summary>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.Add(System.Object)">
            <summary>Adds an element to the end of this collection.</summary>
            <remarks>Adds an element to the end of this collection.</remarks>
            <param name="element"></param>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.ContainsByIdentity(System.Object)">
            <summary>tests if the object is in the Collection.</summary>
            <remarks>tests if the object is in the Collection. == comparison.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.Get(System.Object)">
            <summary>
            returns the first object found in the Collections that equals() the
            passed object
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.Ensure(System.Object)">
            <summary>makes sure the passed object is in the Collection.</summary>
            <remarks>makes sure the passed object is in the Collection. equals() comparison.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.GetEnumerator">
            <summary>
            Iterates through the collection in reversed insertion order which happens
            to be the fastest.
            </summary>
            <remarks>
            Iterates through the collection in reversed insertion order which happens
            to be the fastest.
            </remarks>
            <returns></returns>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.RemoveAll(System.Collections.IEnumerable)">
            <summary>
            Removes all the elements from this collection that are returned by
            iterable.
            </summary>
            <remarks>
            Removes all the elements from this collection that are returned by
            iterable.
            </remarks>
            <param name="iterable"></param>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.RemoveAll(System.Collections.IEnumerator)">
            <summary>
            Removes all the elements from this collection that are returned by
            iterator.
            </summary>
            <remarks>
            Removes all the elements from this collection that are returned by
            iterator.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.Remove(System.Object)">
            <summary>
            removes an object from the Collection equals() comparison returns the
            removed object or null, if none found
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.ToArray(System.Object[])">
            <summary>This is a non reflection implementation for more speed.</summary>
            <remarks>
            This is a non reflection implementation for more speed. In contrast to
            the JDK behaviour, the passed array has to be initialized to the right
            length.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Collection4.InternalIterator">
            <summary>
            Leaner iterator for faster iteration (but unprotected against
            concurrent modifications).
            </summary>
            <remarks>
            Leaner iterator for faster iteration (but unprotected against
            concurrent modifications).
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Collection4Iterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Iterator4Impl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Cool">
            <summary>A collection of cool static methods that should be part of the runtime environment but are not.
            	</summary>
            <remarks>A collection of cool static methods that should be part of the runtime environment but are not.
            	</remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Cool.LoopWithTimeout(System.Int64,Db4objects.Db4o.Foundation.IConditionalBlock)">
            <summary>
            Keeps executing a block of code until it either returns false or millisecondsTimeout
            elapses.
            </summary>
            <remarks>
            Keeps executing a block of code until it either returns false or millisecondsTimeout
            elapses.
            </remarks>
            <param name="millisecondsTimeout"></param>
            <param name="block"></param>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.DynamicVariable">
            <summary>A dynamic variable is a value associated to a specific thread and scope.
            	</summary>
            <remarks>
            A dynamic variable is a value associated to a specific thread and scope.
            The value is brought into scope with the
            <see cref="M:Db4objects.Db4o.Foundation.DynamicVariable.With(System.Object,Db4objects.Db4o.Foundation.IClosure4)">With(object, IClosure4)</see>
            method.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.MappingIterator">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Environments.ConventionBasedEnvironment.Resolve(System.Type)">
            <summary>
            Resolves a service interface to its default implementation using the
            db4o namespace convention:
            interface foo.bar.Baz
            default implementation foo.internal.bar.BazImpl
            </summary>
            <returns>the convention based type name for the requested service</returns>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.FunctionApplicationIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Hashtable4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.HashtableBase">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.HashtableBase.#ctor(Db4objects.Db4o.Foundation.IDeepClone)">
            <param name="cloneOnlyCtor"></param>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.HashtableBase.ValuesIterator">
            <summary>Iterates through all the values.</summary>
            <remarks>Iterates through all the values.</remarks>
            <returns>value iterator</returns>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IFunction4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IMap4">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Hashtable4.#ctor(Db4objects.Db4o.Foundation.IDeepClone)">
            <param name="cloneOnlyCtor"></param>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Hashtable4.Iterator">
            <summary>
            Iterates through all the
            <see cref="T:Db4objects.Db4o.Foundation.IEntry4">entries</see>
            .
            </summary>
            <returns>
            
            <see cref="T:Db4objects.Db4o.Foundation.IEntry4">IEntry4</see>
            iterator
            </returns>
            <seealso cref="M:Db4objects.Db4o.Foundation.HashtableBase.Values">HashtableBase.Values()</seealso>
            <seealso cref="M:Db4objects.Db4o.Foundation.HashtableBase.Keys">
            #see
            <see cref="M:Db4objects.Db4o.Foundation.HashtableBase.ValuesIterator">HashtableBase.ValuesIterator()</see>
            </seealso>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.HashtableObjectEntry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.HashtableIntEntry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IEntry4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.HashtableIdentityEntry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.HashtableIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IComparison4">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.IComparison4.Compare(System.Object,System.Object)">
            <summary>
            Returns negative number if x &lt; y
            Returns zero if x == y
            Returns positive number if x &gt; y
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IIntIterator4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IIntComparator">
            <summary>
            Non boxing/unboxing version of
            <see cref="!:System.Collections.IComparer&lt;T&gt;">System.Collections.IComparer&lt;T&gt;
            	</see>
            for
            faster id comparisons.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IIntObjectVisitor">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IListener4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IPredicate4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IPreparedComparison">
            <summary>
            a prepared comparison, to compare multiple objects
            with one single object.
            </summary>
            <remarks>
            a prepared comparison, to compare multiple objects
            with one single object.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.IPreparedComparison.CompareTo(System.Object)">
            <summary>
            return a negative int, zero or a positive int if
            the object being held in 'this' is smaller, equal
            or greater than the passed object.<br /><br />
            Typical implementation: return this.object - obj;
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IShallowClone">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.ISortable4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IdentitySet4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IntArrayList">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IntByRef">
            <summary>Useful as "out" or "by ref" function parameter.</summary>
            <remarks>Useful as "out" or "by ref" function parameter.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IntIdGenerator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IntIterator4Adaptor">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.IntIterator4Impl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.InvalidIteratorException">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Iterable4Adaptor">
            <summary>
            Adapts Iterable4/Iterator4 iteration model (moveNext, current) to the old db4o
            and jdk model (hasNext, next).
            </summary>
            <remarks>
            Adapts Iterable4/Iterator4 iteration model (moveNext, current) to the old db4o
            and jdk model (hasNext, next).
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Iterators">
            <summary>Iterator primitives (concat, map, reduce, filter, etc...).</summary>
            <remarks>Iterator primitives (concat, map, reduce, filter, etc...).</remarks>
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Foundation.Iterators.Skip">
            <summary>
            Constant indicating that the current element in a
            <see cref="M:Db4objects.Db4o.Foundation.Iterators.Map(System.Collections.IEnumerator,Db4objects.Db4o.Foundation.IFunction4)">Map(IEnumerator, IFunction4)</see>
            operation
            should be skipped.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Iterators.Enumerate(System.Collections.IEnumerable)">
            <summary>
            Generates
            <see cref="!:Tuple">Tuple</see>
            items with indexes starting at 0.
            </summary>
            <param name="iterable">the iterable to be enumerated</param>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Iterators.Map(System.Collections.IEnumerator,Db4objects.Db4o.Foundation.IFunction4)">
            <summary>
            Returns a new iterator which yields the result of applying the function
            to every element in the original iterator.
            </summary>
            <remarks>
            Returns a new iterator which yields the result of applying the function
            to every element in the original iterator.
            <see cref="F:Db4objects.Db4o.Foundation.Iterators.Skip">Skip</see>
            can be returned from function to indicate the current
            element should be skipped.
            </remarks>
            <param name="iterator"></param>
            <param name="function"></param>
            <returns></returns>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Iterators.Flatten(System.Collections.IEnumerator)">
            <summary>Yields a flat sequence of elements.</summary>
            <remarks>
            Yields a flat sequence of elements. Any
            <see cref="T:System.Collections.IEnumerable">IEnumerable</see>
            or
            <see cref="T:System.Collections.IEnumerator">IEnumerator</see>
            found in the original sequence is recursively flattened.
            </remarks>
            <param name="iterator">original sequence</param>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.KeySpec">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.KeySpecHashtable4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.List4">
            <summary>elements in linked list Collection4</summary>
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Foundation.List4._next">
            <summary>next element in list</summary>
        </member>
        <member name="F:Db4objects.Db4o.Foundation.List4._element">
            <summary>carried object</summary>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.List4.#ctor">
            <summary>db4o constructor to be able to store objects of this class</summary>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.ListenerRegistry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.NonblockingQueue">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.ObjectByRef">
            <summary>Useful as "out" or "by ref" function parameter.</summary>
            <remarks>Useful as "out" or "by ref" function parameter.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.SimpleTimer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.SortedCollection4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Stack4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.SynchronizedHashtable4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.TernaryBool">
            <summary>yes/no/dontknow data type</summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.ThreadLocal4">
            <summary>
            ThreadLocal implementation for less capable platforms such as JRE 1.1 and
            Silverlight.
            </summary>
            <remarks>
            ThreadLocal implementation for less capable platforms such as JRE 1.1 and
            Silverlight.
            This class is not intended to be used directly, use
            <see cref="T:Db4objects.Db4o.Foundation.DynamicVariable">DynamicVariable</see>
            .
            WARNING: This implementation might leak Thread references unless
            <see cref="M:Db4objects.Db4o.Foundation.ThreadLocal4.Set(System.Object)">Set(object)</see>
            is called with null on the right thread to clean it up. This
            behavior is currently guaranteed by
            <see cref="T:Db4objects.Db4o.Foundation.DynamicVariable">DynamicVariable</see>
            .
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.TimeStampIdGenerator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.Tree">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Tree.Add(Db4objects.Db4o.Foundation.Tree,System.Int32)">
            <summary>
            On adding a node to a tree, if it already exists, and if
            Tree#duplicates() returns false, #isDuplicateOf() will be
            called.
            </summary>
            <remarks>
            On adding a node to a tree, if it already exists, and if
            Tree#duplicates() returns false, #isDuplicateOf() will be
            called. The added node can then be asked for the node that
            prevails in the tree using #duplicateOrThis(). This mechanism
            allows doing find() and add() in one run.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Tree.AddedOrExisting">
            <summary>
            On adding a node to a tree, if it already exists, and if
            Tree#duplicates() returns false, #onAttemptToAddDuplicate()
            will be called and the existing node will be stored in
            this._preceding.
            </summary>
            <remarks>
            On adding a node to a tree, if it already exists, and if
            Tree#duplicates() returns false, #onAttemptToAddDuplicate()
            will be called and the existing node will be stored in
            this._preceding.
            This node node can then be asked for the node that prevails
            in the tree on adding, using the #addedOrExisting() method.
            This mechanism allows doing find() and add() in one run.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Tree.Compare(Db4objects.Db4o.Foundation.Tree)">
            <summary>
            returns 0, if keys are equal
            uses this - other
            returns positive if this is greater than a_to
            returns negative if this is smaller than a_to
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Tree.Nodes">
            <returns>the number of nodes in this tree for balancing</returns>
        </member>
        <member name="M:Db4objects.Db4o.Foundation.Tree.Size">
            <returns>the number of objects represented.</returns>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.TreeKeyIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.TreeNodeIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Foundation.TreeObject">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.IBlobStatus">
            <exclude></exclude>
            <moveto>com.db4o.internal.blobs</moveto>
        </member>
        <member name="T:Db4objects.Db4o.IBlobTransport">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.IBlobTransport.WriteBlobTo(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Internal.BlobImpl)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IBlobTransport.ReadBlobFrom(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Internal.BlobImpl)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IEmbeddedObjectContainer">
            <summary>
            Represents a local ObjectContainer attached to a
            database file.
            </summary>
            <remarks>
            Represents a local ObjectContainer attached to a
            database file.
            </remarks>
            <since>7.10</since>
        </member>
        <member name="M:Db4objects.Db4o.IEmbeddedObjectContainer.OpenSession">
            <summary>opens a new ObjectContainer against the database file.</summary>
            <remarks>
            opens a new ObjectContainer against the database file.
            The ObjectContainer will have it's own transaction and
            it's own reference system.
            </remarks>
            <returns>the new ObjectContainer session.</returns>
            <since>7.10</since>
        </member>
        <member name="M:Db4objects.Db4o.IEmbeddedObjectContainer.Backup(System.String)">
            <summary>backs up a database file of an open ObjectContainer.</summary>
            <remarks>
            backs up a database file of an open ObjectContainer.
            <br/><br/>While the backup is running, the ObjectContainer can continue to be
            used. Changes that are made while the backup is in progress, will be applied to
            the open ObjectContainer and to the backup.<br/><br/>
            While the backup is running, the ObjectContainer should not be closed.<br/><br/>
            If a file already exists at the specified path, it will be overwritten.<br/><br/>
            The
            <see cref="T:Db4objects.Db4o.IO.IStorage">Db4objects.Db4o.IO.IStorage</see>
            used for backup is the one configured for this container.
            </remarks>
            <param name="path">a fully qualified path</param>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException">db4o database file was closed or failed to open.
            	</exception>
            <exception cref="T:System.NotSupportedException">
            is thrown when the operation is not supported in current
            configuration/environment
            </exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">I/O operation failed or was unexpectedly interrupted.
            	</exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.BinConfiguration">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.IO.BinDecorator">
            <summary>Wrapper baseclass for all classes that wrap Bin.</summary>
            <remarks>
            Wrapper baseclass for all classes that wrap Bin.
            Each class that adds functionality to a Bin must
            extend this class to allow db4o to access the
            delegate instance with
            <see cref="M:Db4objects.Db4o.IO.StorageDecorator.Decorate(Db4objects.Db4o.IO.BinConfiguration,Db4objects.Db4o.IO.IBin)">StorageDecorator.Decorate(BinConfiguration, IBin)
            	</see>
            .
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.IO.IBin">
            <summary>
            Representation of a container for storage of db4o
            database data (to file, to memory).
            </summary>
            <remarks>
            Representation of a container for storage of db4o
            database data (to file, to memory).
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.IBin.Length">
            <summary>returns the length of the Bin (on disc, in memory).</summary>
            <remarks>returns the length of the Bin (on disc, in memory).</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.IBin.Read(System.Int64,System.Byte[],System.Int32)">
            <summary>
            reads a given number of bytes into an array of bytes at an
            offset position.
            </summary>
            <remarks>
            reads a given number of bytes into an array of bytes at an
            offset position.
            </remarks>
            <param name="position">the offset position to read at</param>
            <param name="bytes">the byte array to read bytes into</param>
            <param name="bytesToRead">the number of bytes to be read</param>
            <returns></returns>
        </member>
        <member name="M:Db4objects.Db4o.IO.IBin.Write(System.Int64,System.Byte[],System.Int32)">
            <summary>
            writes a given number of bytes from an array of bytes at
            an offset position
            </summary>
            <param name="position">the offset position to write at</param>
            <param name="bytes">the array of bytes to write</param>
            <param name="bytesToWrite">the number of bytes to write</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.IBin.Sync">
            <summary>
            flushes the buffer content to the physical storage
            media.
            </summary>
            <remarks>
            flushes the buffer content to the physical storage
            media.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.IBin.SyncRead(System.Int64,System.Byte[],System.Int32)">
            <summary>
            reads a given number of bytes into an array of bytes at an
            offset position.
            </summary>
            <remarks>
            reads a given number of bytes into an array of bytes at an
            offset position. In contrast to the normal
            <see cref="M:Db4objects.Db4o.IO.IBin.Read(System.Int64,System.Byte[],System.Int32)">Read(long, byte[], int)</see>
            method, the Bin should ensure direct access to the raw storage medium.
            No caching should take place.
            </remarks>
            <param name="position">the offset position to read at</param>
            <param name="bytes">the byte array to read bytes into</param>
            <param name="bytesToRead">the number of bytes to be read</param>
            <returns></returns>
        </member>
        <member name="M:Db4objects.Db4o.IO.IBin.Close">
            <summary>closes the Bin.</summary>
            <remarks>closes the Bin.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.#ctor(Db4objects.Db4o.IO.IBin)">
            <summary>Default constructor.</summary>
            <remarks>Default constructor.</remarks>
            <param name="bin">
            the
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            that is to be wrapped.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.Close">
            <summary>
            closes the BinDecorator and the underlying
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            .
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.Length">
            <seealso cref="M:Db4objects.Db4o.IO.IBin.Length"></seealso>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.Read(System.Int64,System.Byte[],System.Int32)">
            <seealso cref="M:Db4objects.Db4o.IO.IBin.Read(System.Int64,System.Byte[],System.Int32)">IBin.Read(long, byte[], int)</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.Sync">
            <seealso cref="M:Db4objects.Db4o.IO.IBin.Sync">IBin.Sync()</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.SyncRead(System.Int64,System.Byte[],System.Int32)">
            <seealso cref="M:Db4objects.Db4o.IO.IBin.SyncRead(System.Int64,System.Byte[],System.Int32)">IBin.SyncRead(long, byte[], int)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.IO.BinDecorator.Write(System.Int64,System.Byte[],System.Int32)">
            <seealso cref="M:Db4objects.Db4o.IO.IBin.Write(System.Int64,System.Byte[],System.Int32)">IBin.Write(long, byte[], int)</seealso>
        </member>
        <member name="T:Db4objects.Db4o.IO.BlockAwareBin">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.RegularAddress(System.Int32,System.Int32)">
            <summary>converts address and address offset to an absolute address</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockCopy(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>copies a block within a file in block mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.Copy(System.Int64,System.Int64,System.Int32)">
            <summary>copies a block within a file in absolute mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.Copy(System.Byte[],System.Int64,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockRead(System.Int32,System.Int32,System.Byte[])">
            <summary>reads a buffer at the seeked address</summary>
            <returns>the number of bytes read and returned</returns>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockRead(System.Int32,System.Int32,System.Byte[],System.Int32)">
            <summary>implement to read a buffer at the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockRead(System.Int32,System.Byte[])">
            <summary>reads a buffer at the seeked address</summary>
            <returns>the number of bytes read and returned</returns>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockRead(System.Int32,System.Byte[],System.Int32)">
            <summary>implement to read a buffer at the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.Read(System.Int64,System.Byte[])">
            <summary>reads a buffer at the seeked address</summary>
            <returns>the number of bytes read and returned</returns>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockWrite(System.Int32,System.Int32,System.Byte[])">
            <summary>reads a buffer at the seeked address</summary>
            <returns>the number of bytes read and returned</returns>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockWrite(System.Int32,System.Int32,System.Byte[],System.Int32)">
            <summary>implement to read a buffer at the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockWrite(System.Int32,System.Byte[])">
            <summary>reads a buffer at the seeked address</summary>
            <returns>the number of bytes read and returned</returns>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockWrite(System.Int32,System.Byte[],System.Int32)">
            <summary>implement to read a buffer at the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.Write(System.Int64,System.Byte[])">
            <summary>writes a buffer to the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockSize">
            <summary>returns the block size currently used</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBin.BlockSize(System.Int32)">
            <summary>outside call to set the block size of this adapter</summary>
        </member>
        <member name="T:Db4objects.Db4o.IO.BlockAwareBinWindow">
            <summary>Bounded handle into an IoAdapter: Can only access a restricted area.</summary>
            <remarks>Bounded handle into an IoAdapter: Can only access a restricted area.</remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBinWindow.#ctor(Db4objects.Db4o.IO.BlockAwareBin,System.Int32,System.Int32)">
            <param name="io">The delegate I/O adapter</param>
            <param name="blockOff">The block offset address into the I/O adapter that maps to the start index (0) of this window
            	</param>
            <param name="len">The size of this window in bytes</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBinWindow.Length">
            <returns>Size of this I/O adapter window in bytes.</returns>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBinWindow.Write(System.Int32,System.Byte[])">
            <param name="off">Offset in bytes relative to the window start</param>
            <param name="data">Data to write into the window starting from the given offset</param>
            <exception cref="T:System.ArgumentException"></exception>
            <exception cref="T:System.InvalidOperationException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBinWindow.Read(System.Int32,System.Byte[])">
            <param name="off">Offset in bytes relative to the window start</param>
            <param name="data">Data buffer to read from the window starting from the given offset
            	</param>
            <exception cref="T:System.ArgumentException"></exception>
            <exception cref="T:System.InvalidOperationException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBinWindow.Disable">
            <summary>Disable IO Adapter Window</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.BlockAwareBinWindow.Flush">
            <summary>Flush IO Adapter Window</summary>
        </member>
        <member name="T:Db4objects.Db4o.IO.CachedIoAdapter">
            <summary>
            CachedIoAdapter is an IOAdapter for random access files, which caches data
            for IO access.
            </summary>
            <remarks>
            CachedIoAdapter is an IOAdapter for random access files, which caches data
            for IO access. Its functionality is similar to OS cache.<br/>
            Example:<br/>
            <code>delegateAdapter = new RandomAccessFileAdapter();</code><br/>
            <code>config.Io(new CachedIoAdapter(delegateAdapter));</code><br/>
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.IO.IoAdapter">
            <summary>Base class for database file adapters, both for file and memory databases.
            	</summary>
            <remarks>Base class for database file adapters, both for file and memory databases.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.RegularAddress(System.Int32,System.Int32)">
            <summary>converts address and address offset to an absolute address</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.BlockCopy(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
            <summary>copies a block within a file in block mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.BlockSeek(System.Int32)">
            <summary>sets the read/write pointer in the file using block mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.BlockSeek(System.Int32,System.Int32)">
            <summary>sets the read/write pointer in the file using block mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.BlockSize(System.Int32)">
            <summary>outside call to set the block size of this adapter</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Close">
            <summary>implement to close the adapter</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Copy(System.Int64,System.Int64,System.Int32)">
            <summary>copies a block within a file in absolute mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Copy(System.Byte[],System.Int64,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Delete(System.String)">
            <summary>deletes the given path from whatever 'file system' is addressed</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Exists(System.String)">
            <summary>checks whether a file exists</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.GetLength">
            <summary>implement to return the absolute length of the file</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Open(System.String,System.Boolean,System.Int64,System.Boolean)">
            <summary>implement to open the file</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Read(System.Byte[])">
            <summary>reads a buffer at the seeked address</summary>
            <returns>the number of bytes read and returned</returns>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Read(System.Byte[],System.Int32)">
            <summary>implement to read a buffer at the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Seek(System.Int64)">
            <summary>implement to set the read/write pointer in the file, absolute mode</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Sync">
            <summary>implement to flush the file contents to storage</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Write(System.Byte[])">
            <summary>writes a buffer to the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.Write(System.Byte[],System.Int32)">
            <summary>implement to write a buffer at the seeked address</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.BlockSize">
            <summary>returns the block size currently used</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapter.DelegatedIoAdapter">
            <summary>Delegated IO Adapter</summary>
            <returns>reference to itself</returns>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.#ctor(Db4objects.Db4o.IO.IoAdapter)">
            <summary>
            Creates an instance of CachedIoAdapter with the default page size and
            page count.
            </summary>
            <remarks>
            Creates an instance of CachedIoAdapter with the default page size and
            page count.
            </remarks>
            <param name="ioAdapter">delegate IO adapter (RandomAccessFileAdapter by default)</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.#ctor(Db4objects.Db4o.IO.IoAdapter,System.Int32,System.Int32)">
            <summary>
            Creates an instance of CachedIoAdapter with a custom page size and page
            count.<br />
            </summary>
            <param name="ioAdapter">delegate IO adapter (RandomAccessFileAdapter by default)</param>
            <param name="pageSize">cache page size</param>
            <param name="pageCount">allocated amount of pages</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.#ctor(System.String,System.Boolean,System.Int64,System.Boolean,Db4objects.Db4o.IO.IoAdapter,System.Int32,System.Int32)">
            <summary>Creates an instance of CachedIoAdapter with extended parameters.<br/></summary>
            <param name="path">database file path</param>
            <param name="lockFile">determines if the file should be locked</param>
            <param name="initialLength">initial file length, new writes will start from this point
            	</param>
            <param name="readOnly">
            
            if the file should be used in read-onlyt mode.
            </param>
            <param name="io">delegate IO adapter (RandomAccessFileAdapter by default)</param>
            <param name="pageSize">cache page size</param>
            <param name="pageCount">allocated amount of pages</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Open(System.String,System.Boolean,System.Int64,System.Boolean)">
            <summary>Creates and returns a new CachedIoAdapter <br/></summary>
            <param name="path">database file path</param>
            <param name="lockFile">determines if the file should be locked</param>
            <param name="initialLength">initial file length, new writes will start from this point
            	</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Delete(System.String)">
            <summary>Deletes the database file</summary>
            <param name="path">file path</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Exists(System.String)">
            <summary>Checks if the file exists</summary>
            <param name="path">file path</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.InitIOAdaptor(System.String,System.Boolean,System.Int64,System.Boolean,Db4objects.Db4o.IO.IoAdapter)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Read(System.Byte[],System.Int32)">
            <summary>Reads the file into the buffer using pages from cache.</summary>
            <remarks>
            Reads the file into the buffer using pages from cache. If the next page
            is not cached it will be read from the file.
            </remarks>
            <param name="buffer">destination buffer</param>
            <param name="length">how many bytes to read</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Write(System.Byte[],System.Int32)">
            <summary>Writes the buffer to cache using pages</summary>
            <param name="buffer">source buffer</param>
            <param name="length">how many bytes to write</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Sync">
            <summary>Flushes cache to a physical storage</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.GetLength">
            <summary>Returns the file length</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Close">
            <summary>Flushes and closes the file</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.GetPage(System.Int64,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.GetFreePageFromCache">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.GetPageFromCache(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.FlushAllPages">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.FlushPage(Db4objects.Db4o.IO.CachedIoAdapter.Page)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.GetPageFromDisk(Db4objects.Db4o.IO.CachedIoAdapter.Page,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.IoRead(Db4objects.Db4o.IO.CachedIoAdapter.Page)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.WritePageToDisk(Db4objects.Db4o.IO.CachedIoAdapter.Page)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.Seek(System.Int64)">
            <summary>Moves the pointer to the specified file position</summary>
            <param name="pos">position within the file</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachedIoAdapter.IoSeek(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.CachingBin">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.#ctor(Db4objects.Db4o.IO.IBin,Db4objects.Db4o.Internal.Caching.ICache4,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.Read(System.Int64,System.Byte[],System.Int32)">
            <summary>Reads the file into the buffer using pages from cache.</summary>
            <remarks>
            Reads the file into the buffer using pages from cache. If the next page
            is not cached it will be read from the file.
            </remarks>
            <param name="pos">
            
            start position to read
            </param>
            <param name="buffer">destination buffer</param>
            <param name="length">how many bytes to read</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.Write(System.Int64,System.Byte[],System.Int32)">
            <summary>Writes the buffer to cache using pages</summary>
            <param name="pos">start position to write</param>
            <param name="buffer">source buffer</param>
            <param name="length">how many bytes to write</param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.Sync">
            <summary>Flushes cache to a physical storage</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.Length">
            <summary>Returns the file length</summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.GetPage(System.Int64,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.FlushAllPages">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.FlushPage(Db4objects.Db4o.IO.CachingBin.Page)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.LoadPage(Db4objects.Db4o.IO.CachingBin.Page,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingBin.WritePageToDisk(Db4objects.Db4o.IO.CachingBin.Page)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.CachingStorage">
            <summary>
            Caching storage adapter to cache db4o database data in memory
            until the underlying
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            is instructed to flush its
            data when
            <see cref="M:Db4objects.Db4o.IO.IBin.Sync">IBin.Sync()</see>
            is called.<br/><br/>
            You can override the
            <see cref="M:Db4objects.Db4o.IO.CachingStorage.NewCache">NewCache()</see>
            method if you want to
            work with a different caching strategy.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.IO.StorageDecorator">
            <summary>Wrapper base class for all classes that wrap Storage.</summary>
            <remarks>
            Wrapper base class for all classes that wrap Storage.
            Each class that adds functionality to a Storage must
            extend this class.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.IO.BinDecorator"></seealso>
        </member>
        <member name="T:Db4objects.Db4o.IO.IStorage">
            <summary>
            Base interface for Storage adapters that open a
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            to store db4o database data to.
            </summary>
            <seealso cref="!:Db4objects.Db4o.Config.IFileConfiguration.Storage(IStorage)"></seealso>
        </member>
        <member name="M:Db4objects.Db4o.IO.IStorage.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <summary>
            opens a
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            to store db4o database data.
            </summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IStorage.Exists(System.String)">
            <summary>returns true if a Bin (file or memory) exists with the passed name.</summary>
            <remarks>returns true if a Bin (file or memory) exists with the passed name.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.IStorage.Delete(System.String)">
            <summary>Deletes the bin for the given URI from the storage.</summary>
            <remarks>Deletes the bin for the given URI from the storage.</remarks>
            <since>7.9</since>
            <param name="uri">bin URI</param>
            <exception cref="T:System.IO.IOException">if the bin could not be deleted</exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IStorage.Rename(System.String,System.String)">
            <summary>Renames the bin for the given old URI to the new URI.</summary>
            <remarks>
            Renames the bin for the given old URI to the new URI. If a bin for the new URI
            exists, it will be overwritten.
            </remarks>
            <since>7.9</since>
            <param name="oldUri">URI of the existing bin</param>
            <param name="newUri">future URI of the bin</param>
            <exception cref="T:System.IO.IOException">if the bin could not be deleted</exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.StorageDecorator.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.StorageDecorator.Delete(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.StorageDecorator.Rename(System.String,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingStorage.#ctor(Db4objects.Db4o.IO.IStorage)">
            <summary>
            default constructor to create a Caching storage with the default
            page count of 64 and the default page size of 1024.
            </summary>
            <remarks>
            default constructor to create a Caching storage with the default
            page count of 64 and the default page size of 1024.
            </remarks>
            <param name="storage">
            the
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            to be cached.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingStorage.#ctor(Db4objects.Db4o.IO.IStorage,System.Int32,System.Int32)">
            <summary>
            constructor to set up a CachingStorage with a configured page count
            and page size
            </summary>
            <param name="storage">
            the
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            to be cached.
            </param>
            <param name="pageCount">the number of pages the cache should use.</param>
            <param name="pageSize">the size of the pages the cache should use.</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingStorage.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <summary>opens a Bin for the given URI.</summary>
            <remarks>opens a Bin for the given URI.</remarks>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingStorage.NewCache">
            <summary>
            override this method if you want to work with a different caching
            strategy than the default LRU2Q cache.
            </summary>
            <remarks>
            override this method if you want to work with a different caching
            strategy than the default LRU2Q cache.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.CachingStorage.NonFlushingCachingBin.#ctor(Db4objects.Db4o.IO.IBin,Db4objects.Db4o.Internal.Caching.ICache4,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.ConstantGrowthStrategy">
            <summary>Strategy for file/byte array growth by a constant factor</summary>
        </member>
        <member name="T:Db4objects.Db4o.IO.IGrowthStrategy">
            <summary>Strategy for file/byte array growth.</summary>
            <remarks>Strategy for file/byte array growth.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.IGrowthStrategy.NewSize(System.Int64,System.Int64)">
            <summary>
            returns the incremented size after the growth
            strategy has been applied
            </summary>
            <param name="curSize">the original size</param>
            <returns>
            the new size, after the growth strategy has been
            applied, must be bigger than curSize
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.IO.ConstantGrowthStrategy.#ctor(System.Int32)">
            <param name="growth">The constant growth size</param>
        </member>
        <member name="M:Db4objects.Db4o.IO.ConstantGrowthStrategy.NewSize(System.Int64,System.Int64)">
            <summary>
            returns the incremented size after the growth
            strategy has been applied
            </summary>
            <param name="curSize">the original size</param>
            <returns>the new size</returns>
        </member>
        <member name="T:Db4objects.Db4o.IO.DoublingGrowthStrategy">
            <summary>Strategy for file/byte array growth that will always double the current size
            	</summary>
        </member>
        <member name="T:Db4objects.Db4o.IO.FileStorage">
            <summary>
            Storage adapter to store db4o database data to physical
            files on hard disc.
            </summary>
            <remarks>
            Storage adapter to store db4o database data to physical
            files on hard disc.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <summary>
            opens a
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            on the specified URI (file system path).
            </summary>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.Exists(System.String)">
            <summary>returns true if the specified file system path already exists.</summary>
            <remarks>returns true if the specified file system path already exists.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.Delete(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.Rename(System.String,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.#ctor(Db4objects.Db4o.IO.BinConfiguration)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.Length">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.Read(System.Int64,System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.Seek(System.Int64)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.Sync">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.FileStorage.FileBin.Write(System.Int64,System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.IBlockSize">
            <summary>Block size registry.</summary>
            <remarks>
            Block size registry.
            Accessible through the environment.
            </remarks>
            <seealso cref="!:Db4objects.Db4o.Foundation.Environments.My(System.Type&lt;T&gt;)">Db4objects.Db4o.Foundation.Environments.My(System.Type&lt;T&gt;)
            	</seealso>
            <since>7.7</since>
        </member>
        <member name="T:Db4objects.Db4o.IO.IoAdapterStorage">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapterStorage.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapterStorage.Delete(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.IoAdapterStorage.Rename(System.String,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryBin.Read(System.Int64,System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryBin.Sync">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryBin.Data">
            <summary>Returns a copy of the raw data contained in this bin for external processing.
            	</summary>
            <remarks>
            Returns a copy of the raw data contained in this bin for external processing.
            Access to the data is not guarded by synchronisation. If this method is called
            while the MemoryBin is in use, it is possible that the returned byte array is
            not consistent.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryBin.Write(System.Int64,System.Byte[],System.Int32)">
            <summary>for internal processing only.</summary>
            <remarks>for internal processing only.</remarks>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.MemoryStorage">
            <summary>
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            implementation that produces
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            instances
            that operate in memory.
            Use this
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            to work with db4o as an in-memory database.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryStorage.Exists(System.String)">
            <summary>
            returns true if a MemoryBin with the given URI name already exists
            in this Storage.
            </summary>
            <remarks>
            returns true if a MemoryBin with the given URI name already exists
            in this Storage.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryStorage.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <summary>opens a MemoryBin for the given URI (name can be freely chosen).</summary>
            <remarks>opens a MemoryBin for the given URI (name can be freely chosen).</remarks>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryStorage.Bin(System.String)">
            <summary>Returns the memory bin for the given URI for external use.</summary>
            <remarks>Returns the memory bin for the given URI for external use.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryStorage.Bin(System.String,Db4objects.Db4o.IO.MemoryBin)">
            <summary>Registers the given bin for this storage with the given URI.</summary>
            <remarks>Registers the given bin for this storage with the given URI.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryStorage.Delete(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.MemoryStorage.Rename(System.String,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.NonFlushingStorage">
            <summary>
            Storage adapter that does not pass flush calls
            on to its delegate.
            </summary>
            <remarks>
            Storage adapter that does not pass flush calls
            on to its delegate.
            You can use this
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            for improved db4o
            speed at the risk of corrupted database files in
            case of system failure.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.IO.PagingMemoryBin">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryBin.Read(System.Int64,System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryBin.Sync">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryBin.Write(System.Int64,System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.PagingMemoryStorage">
            <summary>
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            implementation that produces
            <see cref="T:Db4objects.Db4o.IO.IBin">IBin</see>
            instances
            that operate in memory.
            Use this
            <see cref="T:Db4objects.Db4o.IO.IStorage">IStorage</see>
            to work with db4o as an in-memory database.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryStorage.Exists(System.String)">
            <summary>
            returns true if a MemoryBin with the given URI name already exists
            in this Storage.
            </summary>
            <remarks>
            returns true if a MemoryBin with the given URI name already exists
            in this Storage.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryStorage.Open(Db4objects.Db4o.IO.BinConfiguration)">
            <summary>opens a MemoryBin for the given URI (name can be freely chosen).</summary>
            <remarks>opens a MemoryBin for the given URI (name can be freely chosen).</remarks>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryStorage.Bin(System.String)">
            <summary>Returns the memory bin for the given URI for external use.</summary>
            <remarks>Returns the memory bin for the given URI for external use.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryStorage.Bin(System.String,Db4objects.Db4o.IO.IBin)">
            <summary>Registers the given bin for this storage with the given URI.</summary>
            <remarks>Registers the given bin for this storage with the given URI.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryStorage.Delete(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.PagingMemoryStorage.Rename(System.String,System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.RandomAccessFileAdapter">
            <summary>IO adapter for random access files.</summary>
            <remarks>IO adapter for random access files.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.#ctor(System.String,System.Boolean,System.Int64,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.GetLength">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.Open(System.String,System.Boolean,System.Int64,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.Read(System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.Seek(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.Sync">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.RandomAccessFileAdapter.Write(System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.IO.ReadOnlyBin">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.IO.SynchronizedBin">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.IO.VanillaIoAdapter">
            <summary>base class for IoAdapters that delegate to other IoAdapters (decorator pattern)
            	</summary>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.#ctor(Db4objects.Db4o.IO.IoAdapter,System.String,System.Boolean,System.Int64,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.GetLength">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.Read(System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.Seek(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.Sync">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.IO.VanillaIoAdapter.Write(System.Byte[],System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.ITransactionAware">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.ITransactionListener">
            <summary>
            allows registration with a transaction to be notified of
            commit and rollback
            </summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.AbstractBufferContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IBufferContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IReadBuffer">
            <summary>
            a buffer interface with methods to read and to position
            the read pointer in the buffer.
            </summary>
            <remarks>
            a buffer interface with methods to read and to position
            the read pointer in the buffer.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadBuffer.Offset">
            <summary>returns the current offset in the buffer</summary>
            <returns>the offset</returns>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadBuffer.ReadByte">
            <summary>reads a byte from the buffer.</summary>
            <remarks>reads a byte from the buffer.</remarks>
            <returns>the byte</returns>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadBuffer.ReadBytes(System.Byte[])">
            <summary>reads an array of bytes from the buffer.</summary>
            <remarks>
            reads an array of bytes from the buffer.
            The length of the array that is passed as a parameter specifies the
            number of bytes that are to be read. The passed bytes buffer parameter
            is directly filled.
            </remarks>
            <param name="bytes">the byte array to read the bytes into.</param>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadBuffer.ReadInt">
            <summary>reads an int from the buffer.</summary>
            <remarks>reads an int from the buffer.</remarks>
            <returns>the int</returns>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadBuffer.ReadLong">
            <summary>reads a long from the buffer.</summary>
            <remarks>reads a long from the buffer.</remarks>
            <returns>the long</returns>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadBuffer.Seek(System.Int32)">
            <summary>positions the read pointer at the specified position</summary>
            <param name="offset">the desired position in the buffer</param>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IContext">
            <summary>
            common functionality for
            <see cref="T:Db4objects.Db4o.Marshall.IReadContext">IReadContext</see>
            and
            <see cref="T:Db4objects.Db4o.Marshall.IWriteContext">IWriteContext</see>
            and
            <see cref="T:Db4objects.Db4o.Internal.Delete.IDeleteContext">Db4objects.Db4o.Internal.Delete.IDeleteContext
            	</see>
            
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IHandlerVersionContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.ActivationContext4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.IActivationDepth">
            <summary>Controls how deep an object graph is activated.</summary>
            <remarks>Controls how deep an object graph is activated.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.FixedActivationDepth">
            <summary>
            Activates a fixed depth of the object graph regardless of
            any existing activation depth configuration settings.
            </summary>
            <remarks>
            Activates a fixed depth of the object graph regardless of
            any existing activation depth configuration settings.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.FullActivationDepth">
            <summary>Activates the full object graph.</summary>
            <remarks>Activates the full object graph.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.IActivationDepthProvider">
            <summary>Factory for ActivationDepth strategies.</summary>
            <remarks>Factory for ActivationDepth strategies.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Activation.IActivationDepthProvider.ActivationDepthFor(Db4objects.Db4o.Internal.ClassMetadata,Db4objects.Db4o.Internal.Activation.ActivationMode)">
            <summary>Returns an ActivationDepth suitable for the specified class and activation mode.
            	</summary>
            <remarks>Returns an ActivationDepth suitable for the specified class and activation mode.
            	</remarks>
            <param name="classMetadata">root class that's being activated</param>
            <param name="mode">activation mode</param>
            <returns>an appropriate ActivationDepth for the class and activation mode</returns>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Activation.IActivationDepthProvider.ActivationDepth(System.Int32,Db4objects.Db4o.Internal.Activation.ActivationMode)">
            <summary>Returns an ActivationDepth that will activate at most *depth* levels.</summary>
            <remarks>
            Returns an ActivationDepth that will activate at most *depth* levels.
            A special case is Integer.MAX_VALUE (int.MaxValue for .net) for which a
            FullActivationDepth object must be returned.
            </remarks>
            <param name="depth"></param>
            <param name="mode"></param>
            <returns></returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.ITransparentActivationDepthProvider">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.LegacyActivationDepth">
            <summary>
            Activates an object graph to a specific depth respecting any
            activation configuration settings that might be in effect.
            </summary>
            <remarks>
            Activates an object graph to a specific depth respecting any
            activation configuration settings that might be in effect.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Activation.NonDescendingActivationDepth">
            <summary>Transparent Activation strategy.</summary>
            <remarks>Transparent Activation strategy.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TransactionLocal">
            <summary>A transaction local variable.</summary>
            <remarks>A transaction local variable.</remarks>
            <seealso cref="M:Db4objects.Db4o.Internal.Transaction.Get(Db4objects.Db4o.Internal.TransactionLocal)">Transaction.Get(TransactionLocal)
            	</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ArrayType">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.BlobImpl">
            <summary>
            Transfer of blobs to and from the db4o system,
            if users use the Blob Db4oType.
            </summary>
            <remarks>
            Transfer of blobs to and from the db4o system,
            if users use the Blob Db4oType.
            </remarks>
            <moveto>com.db4o.internal.blobs</moveto>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Types.IBlob">
            <summary>
            the db4o Blob type to store blobs independent of the main database
            file and allows to perform asynchronous upload and download operations.
            </summary>
            <remarks>
            the db4o Blob type to store blobs independent of the main database
            file and allows to perform asynchronous upload and download operations.
            <br /><br />
            <b>Usage:</b><br />
            - Define Blob fields on your user classes.<br />
            - As soon as an object of your class is stored, db4o automatically
            takes care that the Blob field is set.<br />
            - Call readFrom to read a blob file into the db4o system.<br />
            - Call writeTo to write a blob file from within the db4o system.<br />
            - getStatus may help you to determine, whether data has been
            previously stored. It may also help you to track the completion
            of the current process.
            <br /><br />
            db4o client/server carries out all blob operations in a separate
            thread on a specially dedicated socket. One socket is used for
            all blob operations and operations are queued. Your application
            may continue to access db4o while a blob is transferred in the
            background.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.GetFileName">
            <summary>returns the name of the file the blob was stored to.</summary>
            <remarks>
            returns the name of the file the blob was stored to.
            <br /><br />The method may return null, if the file was never
            stored.
            </remarks>
            <returns>String the name of the file.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.GetStatus">
            <summary>returns the status after the last read- or write-operation.</summary>
            <remarks>
            returns the status after the last read- or write-operation.
            <br/><br/>The status value returned may be any of the following:<br/>
            <see cref="F:Db4objects.Db4o.Ext.Status.Unused">Db4objects.Db4o.Ext.Status.Unused</see>
            no data was ever stored to the Blob field.<br/>
            <see cref="F:Db4objects.Db4o.Ext.Status.Available">Db4objects.Db4o.Ext.Status.Available
            	</see>
            available data was previously stored to the Blob field.<br/>
            <see cref="F:Db4objects.Db4o.Ext.Status.Queued">Db4objects.Db4o.Ext.Status.Queued</see>
            an operation was triggered and is waiting for it's turn in the Blob queue.<br/>
            <see cref="F:Db4objects.Db4o.Ext.Status.Completed">Db4objects.Db4o.Ext.Status.Completed
            	</see>
            the last operation on this field was completed successfully.<br/>
            <see cref="F:Db4objects.Db4o.Ext.Status.Processing">Db4objects.Db4o.Ext.Status.Processing
            	</see>
            for internal use only.<br/>
            <see cref="F:Db4objects.Db4o.Ext.Status.Error">Db4objects.Db4o.Ext.Status.Error</see>
            the last operation failed.<br/>
            or a double between 0 and 1 that signifies the current completion percentage of the currently
            running operation.<br/><br/> the five
            <see cref="T:Db4objects.Db4o.Ext.Status">Db4objects.Db4o.Ext.Status</see>
            constants defined in this interface or a double
            between 0 and 1 that signifies the completion of the currently running operation.<br/><br/>
            </remarks>
            <returns>status - the current status</returns>
            <seealso cref="T:Db4objects.Db4o.Ext.Status">constants</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.ReadFrom(Sharpen.IO.File)">
            <summary>reads a file into the db4o system and stores it as a blob.</summary>
            <remarks>
            reads a file into the db4o system and stores it as a blob.
            <br/><br/>
            In Client/Server mode db4o will open an additional socket and
            process writing data in an additional thread.
            <br/><br/>
            </remarks>
            <param name="file">the file the blob is to be read from.</param>
            <exception cref="T:System.IO.IOException">in case of errors</exception>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.ReadLocal(Sharpen.IO.File)">
            <summary>reads a file into the db4o system and stores it as a blob.</summary>
            <remarks>
            reads a file into the db4o system and stores it as a blob.
            <br/><br/>
            db4o will use the local file system in Client/Server mode also.
            <br/><br/>
            </remarks>
            <param name="file">the file the blob is to be read from.</param>
            <exception cref="T:System.IO.IOException">in case of errors</exception>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.WriteLocal(Sharpen.IO.File)">
            <summary>writes stored blob data to a file.</summary>
            <remarks>
            writes stored blob data to a file.
            <br/><br/>
            db4o will use the local file system in Client/Server mode also.
            <br/><br/>
            </remarks>
            <exception cref="T:System.IO.IOException">
            in case of errors and in case no blob
            data was stored
            </exception>
            <param name="file">the file the blob is to be written to.</param>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.WriteTo(Sharpen.IO.File)">
            <summary>writes stored blob data to a file.</summary>
            <remarks>
            writes stored blob data to a file.
            <br/><br/>
            In Client/Server mode db4o will open an additional socket and
            process writing data in an additional thread.
            <br/><br/>
            </remarks>
            <exception cref="T:System.IO.IOException">
            in case of errors and in case no blob
            data was stored
            </exception>
            <param name="file">the file the blob is to be written to.</param>
        </member>
        <member name="M:Db4objects.Db4o.Types.IBlob.DeleteFile">
            <summary>Deletes the current file stored in this BLOB.</summary>
            <remarks>Deletes the current file stored in this BLOB.</remarks>
            <exception cref="T:System.IO.IOException">
            in case of errors and in case no
            data was stored
            </exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IDb4oTypeImpl">
            <summary>marker interface for special db4o datatypes</summary>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.AdjustReadDepth(System.Int32)">
            <param name="depth"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.Copy(Sharpen.IO.File,Sharpen.IO.File)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.GetClientInputStream">
            <exception cref="T:System.Exception"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.GetClientOutputStream">
            <exception cref="T:System.Exception"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.ReadFrom(Sharpen.IO.File)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.ReadLocal(Sharpen.IO.File)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.ServerFile(System.String,System.Boolean)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.ServerPath">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.WriteLocal(Sharpen.IO.File)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.WriteTo(Sharpen.IO.File)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.BlobImpl.DeleteFile">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeAlgebra">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeOperation">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.IBTreeRangeVisitor">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeSingleIntersect">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeSingleOperation">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeSingleUnion">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeUnionIntersect">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeUnionOperation">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Algebra.BTreeRangeUnionUnion">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTree">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.PersistentBase">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IPersistent">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ITransactionParticipant">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.IBTreeStructureListener">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Internal.Btree.BTree._nodes">
            <summary>All instantiated nodes are held in this tree.</summary>
            <remarks>All instantiated nodes are held in this tree.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeAdd">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeCancelledRemoval">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeNode">
            <summary>
            We work with BTreeNode in two states:
            - deactivated: never read, no valid members, ID correct or 0 if new
            - write: real representation of keys, values and children in arrays
            The write state can be detected with canWrite().
            </summary>
            <remarks>
            We work with BTreeNode in two states:
            - deactivated: never read, no valid members, ID correct or 0 if new
            - write: real representation of keys, values and children in arrays
            The write state can be detected with canWrite(). States can be changed
            as needed with prepareRead() and prepareWrite().
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.CacheablePersistentBase">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Internal.Btree.BTreeNode._children">
            <summary>Can contain BTreeNode or Integer for ID of BTreeNode</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Btree.BTreeNode.Add(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Foundation.IPreparedComparison,System.Object)">
            <returns>
            the split node if this node is split
            or this if the first key has changed
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Btree.BTreeNode.TraverseAllNodes(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Foundation.IVisitor4)">
            <summary>This traversal goes over all nodes, not just leafs</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeNodeSearchResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreePointer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeRangeSingle">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Btree.IBTreeRange.Pointers">
            <summary>
            Iterates through all the valid pointers in
            this range.
            </summary>
            <remarks>
            Iterates through all the valid pointers in
            this range.
            </remarks>
            <returns>an Iterator4 over BTreePointer value</returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.BTreeRemove">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.FieldIndexKey">
            <summary>
            Composite key for field indexes, first compares on the actual
            indexed field _value and then on the _parentID (which is a
            reference to the containing object).
            </summary>
            <remarks>
            Composite key for field indexes, first compares on the actual
            indexed field _value and then on the _parentID (which is a
            reference to the containing object).
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.FieldIndexKeyHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IIndexable4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IComparable4">
            <summary>Interface for comparison support in queries.</summary>
            <remarks>Interface for comparison support in queries.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IComparable4.PrepareComparison(Db4objects.Db4o.Marshall.IContext,System.Object)">
            <summary>
            creates a prepared comparison to compare multiple objects
            against one single object.
            </summary>
            <remarks>
            creates a prepared comparison to compare multiple objects
            against one single object.
            </remarks>
            <param name="context">the context of the comparison</param>
            <param name="obj">
            the object that is to be compared
            against multiple other objects
            </param>
            <returns>the prepared comparison</returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.SearchTarget">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Btree.Searcher">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ByteArrayBuffer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IReadWriteBuffer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IWriteBuffer">
            <summary>a buffer interface with write methods.</summary>
            <remarks>a buffer interface with write methods.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteBuffer.WriteByte(System.Byte)">
            <summary>writes a single byte to the buffer.</summary>
            <remarks>writes a single byte to the buffer.</remarks>
            <param name="b">the byte</param>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteBuffer.WriteBytes(System.Byte[])">
            <summary>writes an array of bytes to the buffer</summary>
            <param name="bytes">the byte array</param>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteBuffer.WriteInt(System.Int32)">
            <summary>writes an int to the buffer.</summary>
            <remarks>writes an int to the buffer.</remarks>
            <param name="i">the int</param>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteBuffer.WriteLong(System.Int64)">
            <summary>writes a long to the buffer</summary>
            <param name="l">the long</param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ByteArrayBuffer.Read(Db4objects.Db4o.Internal.ObjectContainerBase,System.Int32,System.Int32)">
            <summary>non-encrypted read, used for indexes</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ByteArrayBuffer.ReadEmbeddedObject(Db4objects.Db4o.Internal.Transaction)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ByteArrayBuffer.ReadEncrypt(Db4objects.Db4o.Internal.ObjectContainerBase,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.CacheFactory">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.CacheStatistics">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.ICache4">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Caching.ICache4.Produce(System.Object,Db4objects.Db4o.Foundation.IFunction4,Db4objects.Db4o.Foundation.IProcedure4)">
            <summary>
            Retrieves the value associated to the
            <see cref="!:key">key</see>
            from the cache. If the value is not yet
            cached
            <see cref="!:producer">producer</see>
            will be called to produce it. If the cache needs to discard a value
            <see cref="!:finalizer">finalizer</see>
            will be given a chance to process it.
            </summary>
            <param name="key">the key for the value - must never change - cannot be null</param>
            <param name="producer">will be called if value not yet in the cache - can only be null when the value is found in the cache
            	</param>
            <param name="finalizer">will be called if a page needs to be discarded - can be null
            	</param>
            <returns>the cached value</returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.IPurgeableCache4">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Caching.IPurgeableCache4.Purge(System.Object)">
            <summary>Removes the cached value with the specified key from this cache.</summary>
            <remarks>Removes the cached value with the specified key from this cache.</remarks>
            <param name="key"></param>
            <returns>the purged value or null</returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.LRU2QCache">
            <exclude>
            Simplified version of the algorithm taken from here:
            http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.2641
            </exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.LRU2QLongCache">
            <exclude>
            Simplified version of the algorithm taken from here:
            http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.2641
            </exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.LRU2QXCache">
            <exclude>
            Full version of the algorithm taken from here:
            http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.2641
            </exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.LRUCache">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.LRUIntCache">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Caching.NullCache4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.CallbackObjectInfoCollections">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ClassAspect">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ClassMetadata">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Internal.ClassMetadata._typeHandler">
            <summary>
            For reference types, _typeHandler always holds a StandardReferenceTypeHandler
            that will use the _aspects of this class to take care of its business.
            </summary>
            <remarks>
            For reference types, _typeHandler always holds a StandardReferenceTypeHandler
            that will use the _aspects of this class to take care of its business. A custom
            type handler would appear as a TypeHandlerAspect in that case.
            For value types, _typeHandler always holds the actual value type handler be it
            a custom type handler or a builtin one.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ClassMetadata.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ClassMetadata.HasField(Db4objects.Db4o.Internal.ObjectContainerBase,System.String)">
            <param name="container"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ClassMetadata.IsStronglyTyped">
            <summary>no any, primitive, array or other tricks.</summary>
            <remarks>
            no any, primitive, array or other tricks. overriden in YapClassAny and
            YapClassPrimitive
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IModificationAware">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ClassMetadataIterator">
            <exclude>TODO: remove this class or make it private to ClassMetadataRepository</exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ClassMetadataRepository">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Classindex.AbstractClassIndexStrategy">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Classindex.IClassIndexStrategy">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Classindex.IClassIndexStrategy.TraverseAll(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Foundation.IVisitor4)">
            <summary>Traverses all index entries (java.lang.Integer references).</summary>
            <remarks>Traverses all index entries (java.lang.Integer references).</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Classindex.BTreeClassIndexStrategy">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Collections.BigSet`1">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Collections.BigSetBTreeManager">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Collections.BigSetTypeHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.ITypeHandler4">
            <summary>
            handles reading, writing, deleting, defragmenting and
            comparisons for types of objects.<br/><br/>
            Custom Typehandlers can be implemented to alter the default
            behaviour of storing all non-transient fields of an object.<br/><br/>
            </summary>
            <seealso>
            
            <see cref="M:Db4objects.Db4o.Config.IConfiguration.RegisterTypeHandler(Db4objects.Db4o.Typehandlers.ITypeHandlerPredicate,Db4objects.Db4o.Typehandlers.ITypeHandler4)">Db4objects.Db4o.Config.IConfiguration.RegisterTypeHandler(ITypeHandlerPredicate, ITypeHandler4)
            	</see>
            
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ITypeHandler4.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <summary>gets called when an object gets deleted.</summary>
            <remarks>gets called when an object gets deleted.</remarks>
            <param name="context"></param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException">Db4objects.Db4o.Ext.Db4oIOException
            	</exception>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ITypeHandler4.Defragment(Db4objects.Db4o.Internal.IDefragmentContext)">
            <summary>gets called when an object gets defragmented.</summary>
            <remarks>gets called when an object gets defragmented.</remarks>
            <param name="context"></param>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ITypeHandler4.Write(Db4objects.Db4o.Marshall.IWriteContext,System.Object)">
            <summary>gets called when an object is to be written to the database.</summary>
            <remarks>gets called when an object is to be written to the database.</remarks>
            <param name="context"></param>
            <param name="obj">the object</param>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.IReferenceTypeHandler.Activate(Db4objects.Db4o.Marshall.IReferenceActivationContext)">
            <summary>gets called when an object is to be activated.</summary>
            <remarks>gets called when an object is to be activated.</remarks>
            <param name="context"></param>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.ICascadingTypeHandler">
            <summary>TypeHandler for objects with members.</summary>
            <remarks>TypeHandler for objects with members.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ICascadingTypeHandler.CascadeActivation(Db4objects.Db4o.Typehandlers.IActivationContext)">
            <summary>
            will be called during activation if the handled
            object is already active
            </summary>
            <param name="context"></param>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ICascadingTypeHandler.ReadCandidateHandler(Db4objects.Db4o.Internal.Marshall.QueryingReadContext)">
            <summary>
            will be called during querying to ask for the handler
            to be used to collect children of the handled object
            </summary>
            <param name="context"></param>
            <returns></returns>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ICascadingTypeHandler.CollectIDs(Db4objects.Db4o.Internal.Marshall.QueryingReadContext)">
            <summary>
            will be called during querying to ask for IDs of member
            objects of the handled object.
            </summary>
            <remarks>
            will be called during querying to ask for IDs of member
            objects of the handled object.
            </remarks>
            <param name="context"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Collections.BigSetTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Config4Abstract">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Abstract.Equals(System.Object)">
            <summary>Will raise an exception if argument class doesn't match this class - violates equals() contract in favor of failing fast.
            	</summary>
            <remarks>Will raise an exception if argument class doesn't match this class - violates equals() contract in favor of failing fast.
            	</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Config4Class">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Internal.Config4Class.MaintainMetaclassKey">
            <summary>
            We are running into cyclic dependancies on reading the PBootRecord
            object, if we maintain MetaClass information there
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Class.NewTranslatorFromPlatform(System.String)">
            <exception cref="!:Sharpen.Lang.InstantiationException"></exception>
            <exception cref="T:System.MemberAccessException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Config4Impl">
            <summary>Configuration template for creating new db4o files</summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Messaging.IMessageSender">
            <summary>message sender for client/server messaging.</summary>
            <remarks>
            message sender for client/server messaging.
            <br/><br/>db4o allows using the client/server TCP connection to send
            messages from the client to the server. Any object that can be
            stored to a db4o database file may be used as a message.<br/><br/>
            For an example see Reference documentation: <br/>
            http://developer.db4o.com/Resources/view.aspx/Reference/Client-Server/Messaging<br/>
            http://developer.db4o.com/Resources/view.aspx/Reference/Client-Server/Remote_Code_Execution<br/><br/>
            <b>See Also:</b><br/>
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.GetMessageSender">Db4objects.Db4o.Config.IClientServerConfiguration.GetMessageSender()
            	</see>
            ,<br/>
            <see cref="T:Db4objects.Db4o.Messaging.IMessageRecipient">IMessageRecipient</see>
            ,<br/>
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.SetMessageRecipient(Db4objects.Db4o.Messaging.IMessageRecipient)">Db4objects.Db4o.Config.IClientServerConfiguration.SetMessageRecipient(IMessageRecipient)
            	</see>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Messaging.IMessageSender.Send(System.Object)">
            <summary>sends a message to the server.</summary>
            <remarks>sends a message to the server.</remarks>
            <param name="obj">the message parameter, any object may be used.</param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Impl.ConfigurationItemsIterator">
            <summary>
            Returns an iterator for all
            <see cref="T:Db4objects.Db4o.Config.IConfigurationItem">Db4objects.Db4o.Config.IConfigurationItem
            	</see>
            instances
            added.
            </summary>
            <seealso cref="M:Db4objects.Db4o.Internal.Config4Impl.Add(Db4objects.Db4o.Config.IConfigurationItem)">Add(Db4objects.Db4o.Config.IConfigurationItem)
            	</seealso>
            <returns>the iterator</returns>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Impl.EnsureDirExists(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Impl.ReserveStorageSpace(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Impl.Send(System.Object)">
            <summary>The ConfigImpl also is our messageSender</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Config4Impl.SetBlobPath(System.String)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.References.IReferenceSystemFactory">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ConfigBlock">
            <summary>
            configuration and agent to write the configuration block
            The configuration block also contains the timer lock and
            a pointer to the running transaction.
            </summary>
            <remarks>
            configuration and agent to write the configuration block
            The configuration block also contains the timer lock and
            a pointer to the running transaction.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ConfigBlock.ForNewFile(Db4objects.Db4o.Internal.LocalObjectContainer)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ConfigBlock.ForExistingFile(Db4objects.Db4o.Internal.LocalObjectContainer,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ConfigBlock.#ctor(Db4objects.Db4o.Internal.LocalObjectContainer,System.Boolean,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ConfigBlock.Read(System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ConfigBlock.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Config.CacheConfigurationImpl">
            <exclude></exclude>
        </member>
        <member name="P:Db4objects.Db4o.Internal.Config.FileConfigurationImpl.Storage">
            <exception cref="T:Db4objects.Db4o.Config.GlobalOnlyConfigException"></exception>
        </member>
        <member name="P:Db4objects.Db4o.Internal.Config.FileConfigurationImpl.ReserveStorageSpace">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="P:Db4objects.Db4o.Internal.Config.FileConfigurationImpl.BlobPath">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Const4">
            <exclude>TODO: Split into separate enums with defined range and values.</exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversion">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Convert.Conversion.Convert(Db4objects.Db4o.Internal.Convert.ConversionStage.ClassCollectionAvailableStage)">
            <param name="stage"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Convert.Conversion.Convert(Db4objects.Db4o.Internal.Convert.ConversionStage.SystemUpStage)">
            <param name="stage"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.ConversionStage">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.ClassAspects_7_4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.ClassIndexesToBTrees_5_5">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.CommonConversions">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.DropDateTimeOffsetClassIndexes_7_12">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.DropEnumClassIndexes_7_10">
            <exclude>*</exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.DropGuidClassIndexes_7_12">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.FieldIndexesToBTrees_5_7">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Convert.Conversions.FieldIndexesToBTrees_5_7.FreeOldUUIDMetaIndex(Db4objects.Db4o.Internal.LocalObjectContainer)">
            <param name="file"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Conversions.ReindexNetDateTime_7_8">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Convert.Converter">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.DefragmentContextImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IMarshallingInfo">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IAspectVersionContext">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IDefragmentContext.CopySlotToNewMapped(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IDefragmentContext.SourceBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IDefragmentContext.SourceBufferById(System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.DefragmentContextImpl.CopySlotToNewMapped(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.DefragmentContextImpl.SourceBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.DefragmentContextImpl.SourceBufferById(System.Int32)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.DeleteInfo">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TreeInt">
            <summary>Base class for balanced trees.</summary>
            <remarks>Base class for balanced trees.</remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IReadWriteable">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IReadable">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Delete.DeleteContextImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ObjectHeaderContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.AbstractReadContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IInternalReadContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IReadContext">
            <summary>
            this interface is passed to internal class
            <see cref="T:Db4objects.Db4o.Typehandlers.ITypeHandler4">Db4objects.Db4o.Typehandlers.ITypeHandler4
            	</see>
            when instantiating objects.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadContext.ReadObject">
            <summary>
            Interprets the current position in the context as
            an ID and returns the object with this ID.
            </summary>
            <remarks>
            Interprets the current position in the context as
            an ID and returns the object with this ID.
            </remarks>
            <returns>the object</returns>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReadContext.ReadObject(Db4objects.Db4o.Typehandlers.ITypeHandler4)">
            <summary>
            reads sub-objects, in cases where the
            <see cref="T:Db4objects.Db4o.Typehandlers.ITypeHandler4">Db4objects.Db4o.Typehandlers.ITypeHandler4
            	</see>
            is known.
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Delete.IDeleteContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IObjectIdContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Diagnostic.DiagnosticProcessor">
            <exclude>FIXME: remove me from the core and make me a facade over Events</exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Encoding.BuiltInStringEncoding">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Internal.Encoding.BuiltInStringEncoding.AllEncodings">
            <summary>keep the position in the array.</summary>
            <remarks>
            keep the position in the array.
            Information is used to look up encodings.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Encoding.DelegatingStringIO">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Encoding.LatinStringIO">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Encoding.DelegatingStringIO.WriteLengthAndString(Db4objects.Db4o.Marshall.IWriteBuffer,System.String)">
            <summary>
            Note the different implementation when compared to LatinStringIO and UnicodeStringIO:
            Instead of writing the length of the string, UTF8StringIO writes the length of the
            byte array.
            </summary>
            <remarks>
            Note the different implementation when compared to LatinStringIO and UnicodeStringIO:
            Instead of writing the length of the string, UTF8StringIO writes the length of the
            byte array.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Encoding.LatinStringEncoding">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Encoding.UnicodeStringEncoding">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Encoding.UnicodeStringIO">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.EventDispatchers">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Events.EventRegistryImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Exceptions4">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Exceptions4.CatchAllExceptDb4oException(System.Exception)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ExternalObjectContainer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ObjectContainerBase">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Types.ITransientClass">
            <summary>Marker interface to denote that a class should not be stored by db4o.</summary>
            <remarks>Marker interface to denote that a class should not be stored by db4o.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IObjectContainerSpec">
            <summary>Workaround to provide the Java 5 version with a hook to add ExtObjectContainer.
            	</summary>
            <remarks>
            Workaround to provide the Java 5 version with a hook to add ExtObjectContainer.
            (Generic method declarations won't match ungenerified YapStreamBase implementations
            otherwise and implementing it directly kills .NET conversion.)
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IInternalObjectContainer">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Open">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.OpenImpl">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Backup(System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Bind(Db4objects.Db4o.Internal.Transaction,System.Object,System.Int64)">
            <exception cref="T:System.ArgumentNullException"></exception>
            <exception cref="T:System.ArgumentException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.CheckClosed">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.CheckReadOnly">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Commit(Db4objects.Db4o.Internal.Transaction)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Db4oTypeStored(Db4objects.Db4o.Internal.Transaction,System.Object)">
            <summary>allows special handling for all Db4oType objects.</summary>
            <remarks>
            allows special handling for all Db4oType objects.
            Redirected here from #set() so only instanceof check is necessary
            in the #set() method.
            </remarks>
            <returns>object if handled here and #set() should not continue processing</returns>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Deactivate(Db4objects.Db4o.Internal.Transaction,System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Delete(Db4objects.Db4o.Internal.Transaction,System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.TryGetByID(Db4objects.Db4o.Internal.Transaction,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.GetByID(Db4objects.Db4o.Internal.Transaction,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.GetActiveClassMetadata(Db4objects.Db4o.Reflect.IReflectClass)">
            <summary>
            Differentiating getActiveClassMetadata from getYapClass is a tuning
            optimization: If we initialize a YapClass, #set3() has to check for
            the possibility that class initialization associates the currently
            stored object with a previously stored static object, causing the
            object to be known afterwards.
            </summary>
            <remarks>
            Differentiating getActiveClassMetadata from getYapClass is a tuning
            optimization: If we initialize a YapClass, #set3() has to check for
            the possibility that class initialization associates the currently
            stored object with a previously stored static object, causing the
            object to be known afterwards.
            In this call we only return active YapClasses, initialization
            is not done on purpose
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Initialize2">
            <summary>before file is open</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Initialize2NObjectCarrier">
            <summary>overridden in YapObjectCarrier</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.PeekPersisted(Db4objects.Db4o.Internal.Transaction,System.Object,Db4objects.Db4o.Internal.Activation.IActivationDepth,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.ReadBytes(System.Byte[],System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.ReadBytes(System.Byte[],System.Int32,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.DecryptedBufferByAddress(System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.CheckAddress(System.Int32)">
            <exception cref="T:System.ArgumentException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.ReadWriterByAddress(Db4objects.Db4o.Internal.Transaction,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Send(System.Object)">
            <param name="obj"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Store(Db4objects.Db4o.Internal.Transaction,System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.Store(Db4objects.Db4o.Internal.Transaction,System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.StoreInternal(Db4objects.Db4o.Internal.Transaction,System.Object,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.StoreInternal(Db4objects.Db4o.Internal.Transaction,System.Object,System.Int32,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerBase.ShowInternalClasses(System.Boolean)">
            <summary>
            Objects implementing the "Internal4" marker interface are
            not visible to queries, unless this flag is set to true.
            </summary>
            <remarks>
            Objects implementing the "Internal4" marker interface are
            not visible to queries, unless this flag is set to true.
            The caller should reset the flag after the call.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Internal.ObjectContainerBase.IsClient">
            <summary>
            overridden in ClientObjectContainer
            The method allows checking whether will make it easier to refactor than
            an "instanceof YapClient" check.
            </summary>
            <remarks>
            overridden in ClientObjectContainer
            The method allows checking whether will make it easier to refactor than
            an "instanceof YapClient" check.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Query.IQueryComparator">
            <summary>
            This interface is not used in .NET.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQueryComparator.Compare(System.Object,System.Object)">
            <summary>Implement to compare two arguments for sorting.</summary>
            <remarks>
            Implement to compare two arguments for sorting.
            Return a negative value, zero, or a positive value if
            the first argument is smaller, equal or greater than
            the second.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Activate(System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Bind(System.Object,System.Int64)">
            <exception cref="T:System.ArgumentNullException"></exception>
            <exception cref="T:System.ArgumentException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Commit">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Deactivate(System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Get(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.QueryByExample(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.GetByID(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.PeekPersisted(System.Object,System.Int32,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Set(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Store(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Set(System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Store(System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.Backup(Db4objects.Db4o.IO.IStorage,System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ExternalObjectContainer.ReplicationBegin(Db4objects.Db4o.IObjectContainer,Db4objects.Db4o.Replication.IReplicationConflictHandler)">
            <param name="peerB"></param>
            <param name="conflictHandler"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.FieldMetadata">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.AddFieldIndex(Db4objects.Db4o.Internal.Marshall.ObjectIdContextImpl,Db4objects.Db4o.Internal.Slots.Slot)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.ReadIndexEntry(Db4objects.Db4o.Internal.Marshall.IObjectIdContext)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.CollectIDs(Db4objects.Db4o.Internal.Marshall.CollectIdContext)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.Delete(Db4objects.Db4o.Internal.Delete.DeleteContextImpl,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.RemoveIndexEntry(Db4objects.Db4o.Internal.Delete.DeleteContextImpl)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.GetOrCreate(Db4objects.Db4o.Internal.Transaction,System.Object)">
            <summary>
            dirty hack for com.db4o.types some of them need to be set automatically
            TODO: Derive from YapField for Db4oTypes
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.GetIndex(Db4objects.Db4o.Internal.Transaction)">
            <param name="trans"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.FieldMetadata.RebuildIndexForObject(Db4objects.Db4o.Internal.LocalObjectContainer,Db4objects.Db4o.Internal.ClassMetadata,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.FieldMetadataState">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fieldindex.IndexedLeaf">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fileheader.FileHeader">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader.ReadFixedPart(Db4objects.Db4o.Internal.LocalObjectContainer)">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader.InitNew(Db4objects.Db4o.Internal.LocalObjectContainer)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fileheader.FileHeader0">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader0.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader0.ReadFixedPart(Db4objects.Db4o.Internal.LocalObjectContainer,Db4objects.Db4o.Internal.ByteArrayBuffer)">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader0.InitNew(Db4objects.Db4o.Internal.LocalObjectContainer)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fileheader.FileHeader1">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader1.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.FileHeader1.InitNew(Db4objects.Db4o.Internal.LocalObjectContainer)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fileheader.FileHeaderVariablePart1">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fileheader.TimerFileLock">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.TimerFileLock.Start">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.TimerFileLock.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.TimerFileLock.CheckIfOtherSessionAlive(Db4objects.Db4o.Internal.LocalObjectContainer,System.Int32,System.Int32,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Fileheader.TimerFileLockDisabled">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Fileheader.TimerFileLockDisabled.CheckIfOtherSessionAlive(Db4objects.Db4o.Internal.LocalObjectContainer,System.Int32,System.Int32,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.IFreespaceManager">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.AddressKeySlotHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.SlotHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.BTreeFreespaceManager">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.FreeSlotNode">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.FreespaceBTree">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.FreespaceManagerIx">
            <summary>Old freespacemanager, before version 7.0.</summary>
            <remarks>
            Old freespacemanager, before version 7.0.
            If it is still in use freespace is dropped.
            <see cref="T:Db4objects.Db4o.Internal.Freespace.BTreeFreespaceManager">BTreeFreespaceManager</see>
            should be used instead.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.IFreespaceListener">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.LengthKeySlotHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Freespace.NullFreespaceListener">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.HandlerRegistry">
            <exclude>
            TODO: This class was written to make ObjectContainerBase
            leaner, so TransportObjectContainer has less members.
            All functionality of this class should become part of
            ObjectContainerBase and the functionality in
            ObjectContainerBase should delegate to independent
            modules without circular references.
            </exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.HandlerVersionRegistry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler">
            <summary>This is the latest version, the one that should be used.</summary>
            <remarks>This is the latest version, the one that should be used.</remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.IValueTypeHandler.Read(Db4objects.Db4o.Marshall.IReadContext)">
            <summary>gets called when an value type is to be read from the database.</summary>
            <remarks>gets called when an value type is to be read from the database.</remarks>
            <param name="context"></param>
            <returns>the read value type</returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.IVariableLengthTypeHandler">
            <summary>
            marker interface for TypeHandlers where the slot
            length can change, depending on the object stored
            </summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IVersionedTypeHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler.DeletePrimitiveEmbedded(Db4objects.Db4o.Internal.StatefulBuffer,Db4objects.Db4o.Internal.PrimitiveTypeMetadata)">
            <param name="classPrimitive"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler1">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler3">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler5">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.Array.ArrayHandler0.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayVersionHelper">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayVersionHelper0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayVersionHelper3">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ArrayVersionHelper5">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.MultidimensionalArrayHandler">
            <summary>n-dimensional array</summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.MultidimensionalArrayHandler0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.MultidimensionalArrayHandler3">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.MultidimensionalArrayIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Array.ReflectArrayIterator">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.BooleanHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.PrimitiveHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IIndexableTypeHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IIndexableTypeHandler.ReadIndexEntryFromObjectSlot(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IIndexableTypeHandler.ReadIndexEntry(Db4objects.Db4o.Internal.Marshall.IObjectIdContext)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IBuiltinTypeHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.PrimitiveHandler.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <param name="mf"></param>
            <param name="buffer"></param>
            <param name="redirect"></param>
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.PrimitiveHandler.Read1(Db4objects.Db4o.Internal.ByteArrayBuffer)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.PrimitiveHandler.ReadIndexEntryFromObjectSlot(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.PrimitiveHandler.ReadIndexEntry(Db4objects.Db4o.Internal.Marshall.IObjectIdContext)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.DateHandler0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.DateHandlerBase">
            <summary>Shared (java/.net) logic for Date handling.</summary>
            <remarks>Shared (java/.net) logic for Date handling.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.LongHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.LongHandler.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.DateHandlerBase.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.DoubleHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.DoubleHandler.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.IntHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.IntHandler.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.FloatHandler.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.HandlerVersion">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.IFieldAwareTypeHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.IVirtualAttributeHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.IntHandler0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.NetTypeHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.NetTypeHandler.Read1(Db4objects.Db4o.Internal.ByteArrayBuffer)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.NullFieldAwareTypeHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.NullFieldAwareTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.PlainObjectHandler">
            <summary>Tyehandler for naked plain objects (java.lang.Object).</summary>
            <remarks>Tyehandler for naked plain objects (java.lang.Object).</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.PlainObjectHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.ShortHandler.Read(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IReadsObjectIds">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler.CollectIDs(Db4objects.Db4o.Internal.Marshall.QueryingReadContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler.CollectIDsByTypehandlerAspect(Db4objects.Db4o.Internal.Marshall.QueryingReadContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler.CollectIDsByInstantiatingCollection(Db4objects.Db4o.Internal.Marshall.QueryingReadContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler.ReadIndexEntryFromObjectSlot(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler.ReadIndexEntry(Db4objects.Db4o.Internal.Marshall.IObjectIdContext)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.MarshallingInfoTraverseAspectCommand">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.StandardReferenceTypeHandler0">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringBasedValueTypeHandlerBase.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.StringHandler">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringHandler.ReadIndexEntryFromObjectSlot(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer)">
            <summary>This readIndexEntry method reads from the parent slot.</summary>
            <remarks>This readIndexEntry method reads from the parent slot.</remarks>
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringHandler.ReadIndexEntry(Db4objects.Db4o.Internal.Marshall.IObjectIdContext)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringHandler.ReadIndexEntry(Db4objects.Db4o.Marshall.IContext,Db4objects.Db4o.Internal.ByteArrayBuffer)">
            <summary>This readIndexEntry method reads from the actual index in the file.</summary>
            <remarks>This readIndexEntry method reads from the actual index in the file.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringHandler.Compare(Db4objects.Db4o.Internal.ByteArrayBuffer,Db4objects.Db4o.Internal.ByteArrayBuffer)">
            <summary>
            returns: -x for left is greater and +x for right is greater
            FIXME: The returned value is the wrong way around.
            </summary>
            <remarks>
            returns: -x for left is greater and +x for right is greater
            FIXME: The returned value is the wrong way around.
            TODO: You will need collators here for different languages.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.StringHandler0">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringHandler0.ReadIndexEntryFromObjectSlot(Db4objects.Db4o.Internal.Marshall.MarshallerFamily,Db4objects.Db4o.Internal.StatefulBuffer)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Handlers.StringHandler0.ReadIndexEntry(Db4objects.Db4o.Internal.Marshall.IObjectIdContext)">
            <exception cref="T:Db4objects.Db4o.CorruptionException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.TypeHandlerPredicatePair">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Versions.OpenTypeHandler0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Handlers.Versions.OpenTypeHandler2">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.OpenTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.OpenTypeHandler.SeekSecondaryOffset(Db4objects.Db4o.Marshall.IReadBuffer,Db4objects.Db4o.Typehandlers.ITypeHandler4)">
            <param name="buffer"></param>
            <param name="typeHandler"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.CollectIdContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.SlotFormatCurrent">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.SlotFormat">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ObjectReference">
            <summary>A weak reference to an known object.</summary>
            <remarks>
            A weak reference to an known object.
            "Known" ~ has been stored and/or retrieved within a transaction.
            References the corresponding ClassMetaData along with further metadata:
            internal id, UUID/version information, ...
            </remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectReference.ContinueSet(Db4objects.Db4o.Internal.Transaction,System.Int32)">
            <summary>return false if class not completely initialized, otherwise true</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectReference.Hc_add(Db4objects.Db4o.Internal.ObjectReference)">
            <summary>HCTREE</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectReference.Id_add(Db4objects.Db4o.Internal.ObjectReference)">
            <summary>IDTREE</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.HardObjectReference">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ICommittedCallbackDispatcher">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IDHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Ids.EmbeddedTransactionLogHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Ids.TransactionLogHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Ids.FileBasedTransactionLogHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IllegalComparisonException">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.InCallback">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.InMemoryObjectContainer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.LocalObjectContainer">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.LocalObjectContainer.ReadThis">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.InMemoryObjectContainer.#ctor(Db4objects.Db4o.Config.IConfiguration,Db4objects.Db4o.Ext.MemoryFile)">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.InMemoryObjectContainer.OpenImpl">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.InMemoryObjectContainer.Backup(Db4objects.Db4o.IO.IStorage,System.String)">
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IntMatcher">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.IoAdaptedObjectContainer">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.#ctor(Db4objects.Db4o.Config.IConfiguration,System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.OpenImpl">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.Backup(Db4objects.Db4o.IO.IStorage,System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.ReadBytes(System.Byte[],System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.ReadBytes(System.Byte[],System.Int32,System.Int32,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.Reserve(System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.IoAdaptedObjectContainer.XByteFreespaceFiller.Fill(Db4objects.Db4o.IO.BlockAwareBinWindow)">
            <exception cref="T:System.IO.IOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.LazyObjectReference">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.LocalTransaction">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Transaction">
            <exclude></exclude>
        </member>
        <member name="F:Db4objects.Db4o.Internal.Transaction._container">
            <summary>
            This is the inside representation to operate against, the actual
            file-based ObjectContainerBase or the client.
            </summary>
            <remarks>
            This is the inside representation to operate against, the actual
            file-based ObjectContainerBase or the client. For all calls
            against this ObjectContainerBase the method signatures that take
            a transaction have to be used.
            </remarks>
        </member>
        <member name="F:Db4objects.Db4o.Internal.Transaction._objectContainer">
            <summary>This is the outside representation to the user.</summary>
            <remarks>
            This is the outside representation to the user. This ObjectContainer
            should use this transaction as it's main user transation, so it also
            allows using the method signatures on ObjectContainer without a
            transaction.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.Get(Db4objects.Db4o.Internal.TransactionLocal)">
            <summary>Retrieves the value of a transaction local variables.</summary>
            <remarks>
            Retrieves the value of a transaction local variables.
            If this is the first time the variable is accessed
            <see cref="M:Db4objects.Db4o.Internal.TransactionLocal.InitialValueFor(Db4objects.Db4o.Internal.Transaction)">TransactionLocal.InitialValueFor(Transaction)
            	</see>
            will provide the initial value.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SetPointer(System.Int32,Db4objects.Db4o.Internal.Slots.Slot)">
            <param name="id"></param>
            <param name="slot"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotDelete(System.Int32,Db4objects.Db4o.Internal.Slots.Slot)">
            <param name="id"></param>
            <param name="slot"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotFreeOnCommit(System.Int32,Db4objects.Db4o.Internal.Slots.Slot)">
            <param name="id"></param>
            <param name="slot"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotFreeOnRollback(System.Int32,Db4objects.Db4o.Internal.Slots.Slot)">
            <param name="id"></param>
            <param name="slot"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotFreeOnRollbackCommitSetPointer(System.Int32,Db4objects.Db4o.Internal.Slots.Slot,System.Boolean)">
            <param name="id"></param>
            <param name="slot"></param>
            <param name="forFreespace"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.ProduceUpdateSlotChange(System.Int32,Db4objects.Db4o.Internal.Slots.Slot)">
            <param name="id"></param>
            <param name="slot"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotFreePointerOnCommit(System.Int32)">
            <param name="id"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotFreePointerOnCommit(System.Int32,Db4objects.Db4o.Internal.Slots.Slot)">
            <param name="id"></param>
            <param name="slot"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Transaction.SlotFreePointerOnRollback(System.Int32)">
            <param name="id"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.LockedTree">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Mapping.MappedIDPair">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Mapping.MappedIDPairHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Mapping.MappingNotFoundException">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.AbstractFieldMarshaller">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IFieldMarshaller">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.AspectType">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.AspectVersionContextImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ClassMarshaller">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ClassMarshaller0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ClassMarshaller1">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ClassMarshaller2">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ContextState">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.FieldMarshaller0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.FieldMarshaller1">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.FieldMarshaller2">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.IdObjectCollector">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.MarshallerFamily">
            <summary>
            Represents a db4o file format version, assembles all the marshallers
            needed to read/write this specific version.
            </summary>
            <remarks>
            Represents a db4o file format version, assembles all the marshallers
            needed to read/write this specific version.
            A marshaller knows how to read/write certain types of values from/to its
            representation on disk for a given db4o file format version.
            Responsibilities are somewhat overlapping with TypeHandler's.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.MarshallingContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IWriteContext">
            <summary>
            this interface is passed to internal class
            <see cref="T:Db4objects.Db4o.Typehandlers.ITypeHandler4">Db4objects.Db4o.Typehandlers.ITypeHandler4
            	</see>
            during marshaling
            and provides methods to marshal objects.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteContext.WriteObject(System.Object)">
            <summary>
            makes sure the object is stored and writes the ID of
            the object to the context.
            </summary>
            <remarks>
            makes sure the object is stored and writes the ID of
            the object to the context.
            Use this method for first class objects only (objects that
            have an identity in the database). If the object can potentially
            be a primitive type, do not use this method but use
            a matching
            <see cref="T:Db4objects.Db4o.Marshall.IWriteBuffer">IWriteBuffer</see>
            method instead.
            </remarks>
            <param name="obj">the object to write.</param>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteContext.WriteObject(Db4objects.Db4o.Typehandlers.ITypeHandler4,System.Object)">
            <summary>
            writes sub-objects, in cases where the
            <see cref="T:Db4objects.Db4o.Typehandlers.ITypeHandler4">Db4objects.Db4o.Typehandlers.ITypeHandler4
            	</see>
            is known.
            </summary>
            <param name="handler">typehandler to be used to write the object.</param>
            <param name="obj">the object to write</param>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IWriteContext.Reserve(System.Int32)">
            <summary>
            reserves a buffer with a specific length at the current
            position, to be written in a later step.
            </summary>
            <remarks>
            reserves a buffer with a specific length at the current
            position, to be written in a later step.
            </remarks>
            <param name="length">the length to be reserved.</param>
            <returns>the ReservedBuffer</returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.MarshallingContextState">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ObjectHeader">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ObjectHeaderAttributes">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.ObjectIdContextImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.QueryingReadContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.RawClassSpec">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.SlotFormat0">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.SlotFormat2">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Marshall.UnmarshallingContext">
            <summary>Wraps the low-level details of reading a Buffer, which in turn is a glorified byte array.
            	</summary>
            <remarks>Wraps the low-level details of reading a Buffer, which in turn is a glorified byte array.
            	</remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IReferenceActivationContext">
            <summary>this interface is passed to reference type handlers.</summary>
            <remarks>this interface is passed to reference type handlers.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.MarshallingBuffer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Marshall.IReservedBuffer">
            <summary>a reserved buffer within a write buffer.</summary>
            <remarks>
            a reserved buffer within a write buffer.
            The usecase this class was written for: A null bitmap should be at the
            beginning of a slot to allow lazy processing. During writing the content
            of the null bitmap is not yet fully known until all members are processed.
            With the Reservedbuffer the space in the slot can be occupied and writing
            can happen after all members are processed.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Marshall.IReservedBuffer.WriteBytes(System.Byte[])">
            <summary>writes a byte array to the reserved buffer.</summary>
            <remarks>writes a byte array to the reserved buffer.</remarks>
            <param name="bytes">the byte array.</param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Messages">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.HierarchyAnalyzer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.IAspectTraversalStrategy">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.ModifiedAspectTraversalStrategy">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Metadata.StandardAspectTraversalStrategy">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Null">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.NullFieldMetadata">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.NullFieldMetadata.PrepareComparison(System.Object)">
            <param name="obj"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ObjectAnalyzer">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerFactory.OpenObjectContainer(Db4objects.Db4o.Config.IEmbeddedConfiguration,System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ObjectContainerSession">
            <exclude></exclude>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Backup(System.String)">
            <param name="path"></param>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Backup(Db4objects.Db4o.IO.IStorage,System.String)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Bind(System.Object,System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.GetByID(System.Int64)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.InvalidIDException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.GetByUUID(Db4objects.Db4o.Ext.Db4oUUID)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.IsStored(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.ReplicationBegin(Db4objects.Db4o.IObjectContainer,Db4objects.Db4o.Replication.IReplicationConflictHandler)">
            <param name="peerB"></param>
            <param name="conflictHandler"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Activate(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Activate(System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Close">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Commit">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
            <exception cref="T:Db4objects.Db4o.Constraints.UniqueFieldValueConstraintViolationException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Deactivate(System.Object,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Deactivate(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Delete(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Get(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.QueryByExample(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Query">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Query(System.Type)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Query(Db4objects.Db4o.Query.Predicate)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Query(Db4objects.Db4o.Query.Predicate,Db4objects.Db4o.Query.IQueryComparator)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Rollback">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Set(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ObjectContainerSession.Store(System.Object)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ObjectID">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ObjectInfoCollectionImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.PrimitiveTypeMetadata">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.PrimitiveTypeMetadata.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.PersistentIntegerArray">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.PreparedArrayContainsComparison">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.IDb4oEnhancedFilter">
            <summary>FIXME: Rename to Db4oEnhancedPredicate</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.PredicateEvaluation">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Query.IEvaluation">
            <summary>for implementation of callback evaluations.</summary>
            <remarks>
            for implementation of callback evaluations.
            <br/><br/>
            To constrain a
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            node with your own callback
            <code>Evaluation</code>, construct an object that implements the
            <code>Evaluation</code> interface and register it by passing it
            to
            <see cref="M:Db4objects.Db4o.Query.IQuery.Constrain(System.Object)">IQuery.Constrain(object)</see>
            .
            <br/><br/>
            Evaluations are called as the last step during query execution,
            after all other constraints have been applied. Evaluations in higher
            level
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            nodes in the query graph are called first.
            <br/><br/>Java client/server only:<br/>
            db4o first attempts to use Java Serialization to allow to pass final
            variables to the server. Please make sure that all variables that are
            used within the
            <see cref="M:Db4objects.Db4o.Query.IEvaluation.Evaluate(Db4objects.Db4o.Query.ICandidate)">Evaluate(ICandidate)</see>
            method are Serializable. This may include
            the class an anonymous Evaluation object is created in. If db4o is
            not successful at using Serialization, the Evaluation is transported
            to the server in a db4o
            <see cref="T:Db4objects.Db4o.IO.MemoryBin">Db4objects.Db4o.IO.MemoryBin</see>
            . In this case final variables can
            not be restored.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Query.IEvaluation.Evaluate(Db4objects.Db4o.Query.ICandidate)">
            <summary>
            callback method during
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">query execution</see>
            .
            </summary>
            <param name="candidate">reference to the candidate persistent object.</param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.IInternalQuery">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QCandidate">
            <summary>Represents an actual object in the database.</summary>
            <remarks>
            Represents an actual object in the database. Forms a tree structure, indexed
            by id. Can have dependents that are doNotInclude'd in the query result when
            this is doNotInclude'd.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Query.ICandidate">
            <summary>
            candidate for
            <see cref="T:Db4objects.Db4o.Query.IEvaluation">IEvaluation</see>
            callbacks.
            <br/><br/>
            During
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">query execution</see>
            all registered
            <see cref="T:Db4objects.Db4o.Query.IEvaluation">IEvaluation</see>
            callback
            handlers are called with
            <see cref="T:Db4objects.Db4o.Query.ICandidate">ICandidate</see>
            proxies that represent the persistent objects that
            meet all other
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            criteria.
            <br/><br/>
            A
            <see cref="T:Db4objects.Db4o.Query.ICandidate">ICandidate</see>
            provides access to the persistent object it
            represents and allows to specify, whether it is to be included in the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            resultset.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Query.ICandidate.GetObject">
            <summary>
            returns the persistent object that is represented by this query
            <see cref="T:Db4objects.Db4o.Query.ICandidate">ICandidate</see>
            .
            </summary>
            <returns>Object the persistent object.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.ICandidate.Include(System.Boolean)">
            <summary>
            specify whether the Candidate is to be included in the
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            resultset.
            <br/><br/>
            This method may be called multiple times. The last call prevails.
            </summary>
            <param name="flag">inclusion.</param>
        </member>
        <member name="M:Db4objects.Db4o.Query.ICandidate.ObjectContainer">
            <summary>
            returns the
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            the Candidate object is stored in.
            </summary>
            <returns>
            the
            <see cref="T:Db4objects.Db4o.IObjectContainer">Db4objects.Db4o.IObjectContainer</see>
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCandidate.Include(System.Boolean)">
            <summary>For external interface use only.</summary>
            <remarks>
            For external interface use only. Call doNotInclude() internally so
            dependancies can be checked.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QCandidates">
            <summary>
            Holds the tree of
            <see cref="T:Db4objects.Db4o.Internal.Query.Processor.QCandidate">QCandidate</see>
            objects and the list of
            <see cref="T:Db4objects.Db4o.Internal.Query.Processor.QCon">QCon</see>
            during query evaluation.
            The query work (adding and removing nodes) happens here.
            Candidates during query evaluation.
            <see cref="T:Db4objects.Db4o.Internal.Query.Processor.QCandidate">QCandidate</see>
            objects are stored in i_root
            </summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QCon">
            <summary>Base class for all constraints on queries.</summary>
            <remarks>Base class for all constraints on queries.</remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Query.IConstraint">
            <summary>
            constraint to limit the objects returned upon
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">query execution</see>
            .
            <br/><br/>
            Constraints are constructed by calling
            <see cref="M:Db4objects.Db4o.Query.IQuery.Constrain(System.Object)">Db4objects.Db4o.Query.IQuery.Constrain
            </see>
            .
            <br/><br/>
            Constraints can be joined with the methods
            <see cref="M:Db4objects.Db4o.Query.IConstraint.And(Db4objects.Db4o.Query.IConstraint)">Db4objects.Db4o.Query.IConstraint.And
            </see>
            and
            <see cref="M:Db4objects.Db4o.Query.IConstraint.Or(Db4objects.Db4o.Query.IConstraint)">Db4objects.Db4o.Query.IConstraint.Or
            </see>
            .
            <br/><br/>
            The methods to modify the constraint evaluation algorithm may
            be merged, to construct combined evaluation rules.
            Examples:
            <ul>
            <li> <code>Constraint.Smaller().Equal()</code> for "smaller or equal" </li>
            <li> <code>Constraint.Not().Like()</code> for "not like" </li>
            <li> <code>Constraint.Not().Greater().Equal()</code> for "not greater or equal" </li>
            </ul>
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.And(Db4objects.Db4o.Query.IConstraint)">
            <summary>links two Constraints for AND evaluation.</summary>
            <remarks>
            links two Constraints for AND evaluation.
            For example:<br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("points").Constrain(101).Smaller().And(query.Descend("name").Constrain("Test Pilot0"));	</code><br/>
            will retrieve all pilots with points less than 101 and name as "Test Pilot0"<br/>
            </remarks>
            <param name="with">
            the other
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            </param>
            <returns>
            a new
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            , that can be used for further calls
            to
            <see cref="M:Db4objects.Db4o.Query.IConstraint.And(Db4objects.Db4o.Query.IConstraint)">And</see>
            and
            <see cref="M:Db4objects.Db4o.Query.IConstraint.Or(Db4objects.Db4o.Query.IConstraint)">Or</see>
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Or(Db4objects.Db4o.Query.IConstraint)">
            <summary>links two Constraints for OR evaluation.</summary>
            <remarks>
            links two Constraints for OR evaluation.
            For example:<br/><br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("points").Constrain(101).Greater().Or(query.Descend("name").Constrain("Test Pilot0"));</code><br/>
            will retrieve all pilots with points more than 101 or pilots with the name "Test Pilot0"<br/>
            </remarks>
            <param name="with">
            the other
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            </param>
            <returns>
            a new
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            , that can be used for further calls
            to
            <see cref="M:Db4objects.Db4o.Query.IConstraint.And(Db4objects.Db4o.Query.IConstraint)">And</see>
            and
            <see cref="M:Db4objects.Db4o.Query.IConstraint.Or(Db4objects.Db4o.Query.IConstraint)">Or</see>
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Equal">
            <summary>
            Used in conjunction with
            <see cref="M:Db4objects.Db4o.Query.IConstraint.Smaller">Db4objects.Db4o.Query.IConstraint.Smaller
            </see>
            or
            <see cref="M:Db4objects.Db4o.Query.IConstraint.Greater">Db4objects.Db4o.Query.IConstraint.Greater
            </see>
            to create constraints
            like "smaller or equal", "greater or equal".
            For example:<br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("points").Constrain(101).Smaller().Equal();</code><br/>
            will return all pilots with points &lt;= 101.<br/>
            </summary>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Greater">
            <summary>sets the evaluation mode to <code>&gt;</code>.</summary>
            <remarks>
            sets the evaluation mode to <code>&gt;</code>.
            For example:<br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("points").Constrain(101).Greater()</code><br/>
            will return all pilots with points &gt; 101.<br/>
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Smaller">
            <summary>sets the evaluation mode to <code>&lt;</code>.</summary>
            <remarks>
            sets the evaluation mode to <code>&lt;</code>.
            For example:<br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("points").Constrain(101).Smaller()</code><br/>
            will return all pilots with points &lt; 101.<br/>
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Identity">
            <summary>sets the evaluation mode to identity comparison.</summary>
            <remarks>
            sets the evaluation mode to identity comparison. In this case only
            objects having the same database identity will be included in the result set.
            For example:<br/>
            <code>Pilot pilot = new Pilot("Test Pilot1", 100);</code><br/>
            <code>Car car = new Car("BMW", pilot);</code><br/>
            <code>container.Store(car);</code><br/>
            <code>// Change the name, the pilot instance stays the same</code><br/>
            <code>pilot.SetName("Test Pilot2");</code><br/>
            <code>// create a new car</code><br/>
            <code>car = new Car("Ferrari", pilot);</code><br/>
            <code>container.Store(car);</code><br/>
            <code>IQuery query = container.Query();</code><br/>
            <code>query.Constrain(typeof(Car));</code><br/>
            <code>// All cars having pilot with the same database identity</code><br/>
            <code>// will be retrieved. As we only created Pilot object once</code><br/>
            <code>// it should mean all car objects</code><br/>
            <code>query.Descend("_pilot").Constrain(pilot).Identity();</code><br/><br/>
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.ByExample">
            <summary>set the evaluation mode to object comparison (query by example).</summary>
            <remarks>set the evaluation mode to object comparison (query by example).</remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Like">
            <summary>sets the evaluation mode to "like" comparison.</summary>
            <remarks>
            sets the evaluation mode to "like" comparison. This mode will include
            all objects having the constrain expression somewhere inside the string field.
            For example:<br/>
            <code>Pilot pilot = new Pilot("Test Pilot1", 100);</code><br/>
            <code>container.Store(pilot);</code><br/>
            <code> ...</code><br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>// All pilots with the name containing "est" will be retrieved</code><br/>
            <code>query.Descend("name").Constrain("est").Like();</code><br/>
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Contains">
            <summary>sets the evaluation mode to containment comparison.</summary>
            <remarks>
            sets the evaluation mode to containment comparison.
            For example:<br/>
            <code>Pilot pilot1 = new Pilot("Test 1", 1);</code><br/>
            <code>list.Add(pilot1);</code><br/>
            <code>Pilot pilot2 = new Pilot("Test 2", 2);</code><br/>
            <code>list.Add(pilot2);</code><br/>
            <code>Team team = new Team("Ferrari", list);</code><br/>
            <code>container.Store(team);</code><br/>
            <code>IQuery query = container.Query();</code><br/>
            <code>query.Constrain(typeof(Team));</code><br/>
            <code>query.Descend("pilots").Constrain(pilot2).Contains();</code><br/>
            will return the Team object as it contains pilot2.<br/>
            If applied to a String object, this constrain will behave as
            <see cref="M:Db4objects.Db4o.Query.IConstraint.Like">Db4objects.Db4o.Query.IConstraint.Like
            </see>
            .
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.StartsWith(System.Boolean)">
            <summary>sets the evaluation mode to string StartsWith comparison.</summary>
            <remarks>
            sets the evaluation mode to string StartsWith comparison.
            For example:<br/>
            <code>Pilot pilot = new Pilot("Test Pilot0", 100);</code><br/>
            <code>container.Store(pilot);</code><br/>
            <code> ...</code><br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("name").Constrain("Test").StartsWith(true);</code><br/>
            </remarks>
            <param name="caseSensitive">comparison will be case sensitive if true, case insensitive otherwise
            </param>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.EndsWith(System.Boolean)">
            <summary>sets the evaluation mode to string EndsWith comparison.</summary>
            <remarks>
            sets the evaluation mode to string EndsWith comparison.
            For example:<br/>
            <code>Pilot pilot = new Pilot("Test Pilot0", 100);</code><br/>
            <code>container.Store(pilot);</code><br/>
            <code> ...</code><br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("name").Constrain("T0").EndsWith(false);</code><br/>
            </remarks>
            <param name="caseSensitive">comparison will be case sensitive if true, case insensitive otherwise
            </param>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.Not">
            <summary>turns on Not() comparison.</summary>
            <remarks>
            turns on Not() comparison. All objects not fullfilling the constrain condition will be returned.
            For example:<br/>
            <code>Pilot pilot = new Pilot("Test Pilot1", 100);</code><br/>
            <code>container.Store(pilot);</code><br/>
            <code> ...</code><br/>
            <code>query.Constrain(typeof(Pilot));</code><br/>
            <code>query.Descend("name").Constrain("t0").EndsWith(true).Not();</code><br/>
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">Db4objects.Db4o.Query.IConstraint</see>
            to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraint.GetObject">
            <summary>
            returns the Object the query graph was constrained with to
            create this
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            .
            </summary>
            <returns>Object the constraining object.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.Collect(Db4objects.Db4o.Internal.Query.Processor.QCandidates)">
            <param name="candidates"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.Evaluate(Db4objects.Db4o.Internal.Query.Processor.QCandidate)">
            <param name="candidate"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.EvaluateEvaluationsExec(Db4objects.Db4o.Internal.Query.Processor.QCandidates,System.Boolean)">
            <param name="candidates"></param>
            <param name="rereadObject"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.EvaluateSimpleExec(Db4objects.Db4o.Internal.Query.Processor.QCandidates)">
            <param name="candidates"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.OnSameFieldAs(Db4objects.Db4o.Internal.Query.Processor.QCon)">
            <param name="other"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.ShareParent(System.Object,Db4objects.Db4o.Foundation.BooleanByRef)">
            <param name="obj"></param>
            <param name="removeExisting"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QCon.ShareParentForClass(Db4objects.Db4o.Reflect.IReflectClass,Db4objects.Db4o.Foundation.BooleanByRef)">
            <param name="claxx"></param>
            <param name="removeExisting"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConClass">
            <summary>Class constraint on queries</summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConObject">
            <summary>Object constraint on queries</summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConEvaluation">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConJoin">
            <summary>Join constraint on queries</summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConPath">
            <summary>
            Placeholder for a constraint, only necessary to attach children
            to the query graph.
            </summary>
            <remarks>
            Placeholder for a constraint, only necessary to attach children
            to the query graph.
            Added upon a call to Query#descend(), if there is no
            other place to hook up a new constraint.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConUnconditional">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QConstraints">
            <summary>Array of constraints for queries.</summary>
            <remarks>
            Array of constraints for queries.
            Necessary to be returned to Query#constraints()
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Query.IConstraints">
            <summary>
            set of
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            objects.
            <br/><br/>This extension of the
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            interface allows
            setting the evaluation mode of all contained
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            objects with single calls.
            <br/><br/>
            See also
            <see cref="M:Db4objects.Db4o.Query.IQuery.Constraints">IQuery.Constraints()</see>
            .
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Query.IConstraints.ToArray">
            <summary>
            returns an array of the contained
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            objects.
            </summary>
            <returns>
            an array of the contained
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            objects.
            </returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QE">
            <summary>Query Evaluator - Represents such things as &gt;, &gt;=, &lt;, &lt;=, EQUAL, LIKE, etc.
            	</summary>
            <remarks>Query Evaluator - Represents such things as &gt;, &gt;=, &lt;, &lt;=, EQUAL, LIKE, etc.
            	</remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QE.IndexBitMap(System.Boolean[])">
            <summary>Specifies which part of the index to take.</summary>
            <remarks>
            Specifies which part of the index to take.
            Array elements:
            [0] - smaller
            [1] - equal
            [2] - greater
            [3] - nulls
            </remarks>
            <param name="bits"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEAbstract">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEContains">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEStringCmp">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QEStringCmp.#ctor">
            <summary>for C/S messaging only</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QEContains.#ctor">
            <summary>for C/S messaging only</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEEndsWith">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QEEndsWith.#ctor">
            <summary>for C/S messaging only</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEEqual">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEGreater">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEIdentity">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEMulti">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QENot">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QESmaller">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QEStartsWith">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QEStartsWith.#ctor">
            <summary>for C/S messaging only</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QField">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QPending">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QQuery">
            <summary>QQuery is the users hook on our graph.</summary>
            <remarks>
            QQuery is the users hook on our graph.
            A QQuery is defined by it's constraints.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Processor.QQueryBase">
            <summary>QQuery is the users hook on our graph.</summary>
            <remarks>
            QQuery is the users hook on our graph.
            A QQuery is defined by it's constraints.
            NOTE: This is just a 'partial' base class to allow for variant implementations
            in db4oj and db4ojdk1.2. It assumes that itself is an instance of QQuery
            and should never be used explicitly.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QQueryBase.Constrain(System.Object)">
            <summary>Search for slot that corresponds to class.</summary>
            <remarks>
            Search for slot that corresponds to class. <br />If not found add it.
            <br />Constrain it. <br />
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Processor.QQueryBase.Orderings">
            <summary>Public so it can be used by the LINQ test cases.</summary>
            <remarks>Public so it can be used by the LINQ test cases.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Query.IQuery">
            <summary>handle to a node in a S.O.D.A.</summary>
            <remarks>
            handle to a node in a S.O.D.A. query graph.
            <br/><br/>
            A node in the query graph can represent multiple
            classes, one class or an attribute of a class.<br/><br/>The graph
            is automatically extended with attributes of added constraints
            (see
            <see cref="M:Db4objects.Db4o.Query.IQuery.Constrain(System.Object)">Constrain(object)</see>
            ) and upon calls to
            <see cref="M:Db4objects.Db4o.Query.IQuery.Descend(System.String)">Descend(string)</see>
            that request nodes that do not yet exist.
            <br/><br/>
            References to joined nodes in the query graph can be obtained
            by "walking" along the nodes of the graph with the method
            <see cref="M:Db4objects.Db4o.Query.IQuery.Descend(System.String)">Descend(string)</see>
            .
            <br/><br/>
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Execute()</see>
            evaluates the entire graph against all persistent objects.
            <br/><br/>
            <see cref="M:Db4objects.Db4o.Query.IQuery.Execute">Execute()</see>
            can be called from any
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            node
            of the graph. It will return an
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            filled with
            objects of the class/classes that the node, it was called from,
            represents.<br/><br/>
            <b>Note:<br/>
            <see cref="T:Db4objects.Db4o.Query.Predicate">Native queries</see>
            are the recommended main query
            interface of db4o.</b>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.Constrain(System.Object)">
            <summary>adds a constraint to this node.</summary>
            <remarks>
            adds a constraint to this node.
            <br/><br/>
            If the constraint contains attributes that are not yet
            present in the query graph, the query graph is extended
            accordingly.
            <br/><br/>
            Special behaviour for:
            <ul>
            <li> class
            <see cref="!:System.Type&lt;T&gt;">System.Type&lt;T&gt;</see>
            : confine the result to objects of one
            class or to objects implementing an interface.</li>
            <li> interface
            <see cref="T:Db4objects.Db4o.Query.IEvaluation">IEvaluation</see>
            : run
            evaluation callbacks against all candidates.</li>
            </ul>
            </remarks>
            <param name="constraint">the constraint to be added to this Query.</param>
            <returns>
            
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            a new
            <see cref="T:Db4objects.Db4o.Query.IConstraint">IConstraint</see>
            for this
            query node or <code>null</code> for objects implementing the
            <see cref="T:Db4objects.Db4o.Query.IEvaluation">IEvaluation</see>
            interface.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.Constraints">
            <summary>
            returns a
            <see cref="T:Db4objects.Db4o.Query.IConstraints">IConstraints</see>
            object that holds an array of all constraints on this node.
            </summary>
            <returns>
            
            <see cref="T:Db4objects.Db4o.Query.IConstraints">IConstraints</see>
            on this query node.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.Descend(System.String)">
            <summary>returns a reference to a descendant node in the query graph.</summary>
            <remarks>
            returns a reference to a descendant node in the query graph.
            <br/><br/>If the node does not exist, it will be created.
            <br/><br/>
            All classes represented in the query node are tested, whether
            they contain a field with the specified field name. The
            descendant Query node will be created from all possible candidate
            classes.
            </remarks>
            <param name="fieldName">path to the descendant.</param>
            <returns>
            descendant
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            node
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.Execute">
            <summary>
            executes the
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            .
            </summary>
            <returns>
            
            <see cref="T:Db4objects.Db4o.IObjectSet">Db4objects.Db4o.IObjectSet</see>
            - the result of the
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            .
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.OrderAscending">
            <summary>
            adds an ascending ordering criteria to this node of
            the query graph.
            </summary>
            <remarks>
            adds an ascending ordering criteria to this node of
            the query graph.
            <p>
            If multiple ordering criteria are applied, the chronological
            order of method calls is relevant: criteria created by 'earlier' calls are
            considered more significant, i.e. 'later' criteria only have an effect
            for elements that are considered equal by all 'earlier' criteria.
            </p>
            <p>
            As an example, consider a type with two int fields, and an instance set
            {(a:1,b:3),(a:2,b:2),(a:1,b:2),(a:2,b:3)}. The call sequence [orderAscending(a),
            orderDescending(b)] will result in [(<b>a:1</b>,b:3),(<b>a:1</b>,b:2),(<b>a:2</b>,b:3),(<b>a:2</b>,b:2)].
            </p>
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            object to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.OrderDescending">
            <summary>
            adds a descending order criteria to this node of
            the query graph.
            </summary>
            <remarks>
            adds a descending order criteria to this node of
            the query graph.
            <br/><br/>
            For semantics of multiple calls setting ordering criteria, see
            <see cref="M:Db4objects.Db4o.Query.IQuery.OrderAscending">OrderAscending()</see>
            .
            </remarks>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            object to allow the chaining of method calls.
            </returns>
        </member>
        <member name="M:Db4objects.Db4o.Query.IQuery.SortBy(Db4objects.Db4o.Query.IQueryComparator)">
            <summary>Sort the resulting ObjectSet by the given comparator.</summary>
            <remarks>Sort the resulting ObjectSet by the given comparator.</remarks>
            <param name="comparator">The comparator to apply.</param>
            <returns>
            this
            <see cref="T:Db4objects.Db4o.Query.IQuery">IQuery</see>
            object to allow the chaining of method calls.
            </returns>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.AbstractLateQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.AbstractQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.IQueryResult">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Result.AbstractQueryResult.GetId(System.Int32)">
            <param name="i"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Result.AbstractQueryResult.LoadFromClassIndex(Db4objects.Db4o.Internal.ClassMetadata)">
            <param name="c"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Result.AbstractQueryResult.LoadFromClassIndexes(Db4objects.Db4o.Internal.ClassMetadataIterator)">
            <param name="i"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Result.AbstractQueryResult.LoadFromIdReader(System.Collections.IEnumerator)">
            <param name="ids"></param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Query.Result.AbstractQueryResult.LoadFromQuery(Db4objects.Db4o.Internal.Query.Processor.QQuery)">
            <param name="q"></param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.HybridQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.IdListQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.IdTreeQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.LazyQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.SnapShotQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.Result.StatefulQueryResult">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.References.HashcodeReferenceSystem">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.References.IReferenceSystem">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.References.ReferenceSystemRegistry">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.References.TransactionalReferenceSystem">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.References.TransactionalReferenceSystemBase">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.ReflectException">
            <summary>
            db4o-specific exception.<br/>
            <br/>
            This exception is thrown when one of the db4o reflection methods fails.
            </summary>
            <remarks>
            db4o-specific exception.<br/>
            <br/>
            This exception is thrown when one of the db4o reflection methods fails.
            </remarks>
            <seealso cref="N:Db4objects.Db4o.Reflect">Db4objects.Db4o.Reflect</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ReflectException.#ctor(System.Exception)">
            <summary>Constructor with the cause exception</summary>
            <param name="cause">cause exception</param>
        </member>
        <member name="M:Db4objects.Db4o.Internal.ReflectException.#ctor(System.String)">
            <summary>Constructor with message</summary>
            <param name="message">detailed explanation</param>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Reflect.IFieldAccessor">
            <since>7.7</since>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Reflect.LenientFieldAccessor">
            <since>7.7</since>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Reflect.StrictFieldAccessor">
            <since>7.7</since>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Reflection4">
            <exclude>
            Use the methods in this class for system classes only, since they
            are not ClassLoader or Reflector-aware.
            TODO: this class should go to foundation.reflect, along with ReflectException and ReflectPlatform
            </exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.Object,System.String)">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.Object,System.String,System.Object[])">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.Object,System.String,System.Type[],System.Object[])">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.Type,System.String,System.Type[],System.Object[])">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.String,System.String,System.Type[],System.Object[],System.Object)">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.Object[],System.Object,System.Reflection.MethodInfo)">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.GetMethod(System.String,System.String,System.Type[])">
            <summary>calling this method "method" will break C# conversion with the old converter
            	</summary>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.Invoke(System.Object,System.String,System.Type,System.Object)">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Reflection4.GetFieldValue(System.Object,System.String)">
            <exception cref="T:System.MemberAccessException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Replication.IDb4oReplicationReference">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Replication.IDb4oReplicationReferenceProvider">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.SerializedGraph">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Serializer">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.SharedIndexedFields">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Slots.Pointer4">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Slots.ReferencedSlot">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Slots.Slot">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Slots.SlotChange">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Slots.SlotChange.IsFreePointerOnRollback">
            <summary>FIXME:	Check where pointers should be freed on commit.</summary>
            <remarks>
            FIXME:	Check where pointers should be freed on commit.
            This should be triggered in this class.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Internal.StatefulBuffer">
            <summary>
            public for .NET conversion reasons
            TODO: Split this class for individual usecases.
            </summary>
            <remarks>
            public for .NET conversion reasons
            TODO: Split this class for individual usecases. Only use the member
            variables needed for the respective usecase.
            </remarks>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.StatefulBuffer.Read">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.StoredClassImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.StoredFieldImpl">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.SystemData">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.SystemInfoFileImpl">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Threading.IThreadPool4.Join(System.Int32)">
            <exception cref="T:System.Exception"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.Threading.ThreadPool4Impl.Join(System.Int32)">
            <exception cref="T:System.Exception"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TransactionContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TransactionObjectCarrier">
            <summary>TODO: Check if all time-consuming stuff is overridden!</summary>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Transactionlog.EmbeddedTransactionLogHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Transactionlog.TransactionLogHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.Transactionlog.FileBasedTransactionLogHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TransportObjectContainer">
            <summary>
            no reading
            no writing
            no updates
            no weak references
            navigation by ID only both sides need synchronised ClassCollections and
            MetaInformationCaches
            </summary>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.TransportObjectContainer.StoreInternal(Db4objects.Db4o.Internal.Transaction,System.Object,System.Int32,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseClosedException"></exception>
            <exception cref="T:Db4objects.Db4o.Ext.DatabaseReadOnlyException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.TransportObjectContainer.OpenImpl">
            <exception cref="T:Db4objects.Db4o.Ext.OldFormatException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.TransportObjectContainer.Backup(Db4objects.Db4o.IO.IStorage,System.String)">
            <exception cref="T:System.NotSupportedException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TreeIntObject">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TreeReader">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TypeHandlerAspect">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TypeHandlerCloneContext">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.TypeHandlerConfiguration">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.UUIDFieldMetadata">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.VirtualFieldMetadata">
            <summary>
            TODO: refactor for symmetric inheritance - don't inherit from YapField and override,
            instead extract an abstract superclass from YapField and let both YapField and this class implement
            </summary>
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.VirtualFieldMetadata.AddFieldIndex(Db4objects.Db4o.Internal.Marshall.ObjectIdContextImpl,Db4objects.Db4o.Internal.Slots.Slot)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.UUIDFieldMetadata.AddFieldIndex(Db4objects.Db4o.Internal.Marshall.ObjectIdContextImpl,Db4objects.Db4o.Internal.Slots.Slot)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.UUIDFieldMetadata.ReadDatabaseIdentityIDAndUUID(Db4objects.Db4o.Internal.ObjectContainerBase,Db4objects.Db4o.Internal.ClassMetadata,Db4objects.Db4o.Internal.Slots.Slot,System.Boolean)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Internal.UUIDFieldMetadata.RebuildIndexForObject(Db4objects.Db4o.Internal.LocalObjectContainer,Db4objects.Db4o.Internal.ClassMetadata,System.Int32)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.VersionFieldMetadata">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Internal.VersionFieldMetadata.AddFieldIndex(Db4objects.Db4o.Internal.Marshall.ObjectIdContextImpl,Db4objects.Db4o.Internal.Slots.Slot)">
            <exception cref="T:Db4objects.Db4o.Internal.FieldIndexException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Internal.VirtualAttributes">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Internal.WriteUpdateProcessor">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Messaging.IMessageContext">
            <summary>Additional message-related information.</summary>
            <remarks>Additional message-related information.</remarks>
        </member>
        <member name="P:Db4objects.Db4o.Messaging.IMessageContext.Container">
            <summary>The container the message was dispatched to.</summary>
            <remarks>The container the message was dispatched to.</remarks>
        </member>
        <member name="P:Db4objects.Db4o.Messaging.IMessageContext.Sender">
            <summary>The sender of the current message.</summary>
            <remarks>
            The sender of the current message.
            The reference can be used to send a reply to it.
            </remarks>
        </member>
        <member name="P:Db4objects.Db4o.Messaging.IMessageContext.Transaction">
            <summary>The transaction the current message has been sent with.</summary>
            <remarks>The transaction the current message has been sent with.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Messaging.IMessageRecipient">
            <summary>message recipient for client/server messaging.</summary>
            <remarks>
            message recipient for client/server messaging.
            <br/><br/>db4o allows using the client/server TCP connection to send
            messages from the client to the server. Any object that can be
            stored to a db4o database file may be used as a message.<br/><br/>
            For an example see Reference documentation: <br/>
            http://developer.db4o.com/Resources/view.aspx/Reference/Client-Server/Messaging<br/>
            http://developer.db4o.com/Resources/view.aspx/Reference/Client-Server/Remote_Code_Execution<br/><br/>
            <b>See Also:</b><br/>
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.SetMessageRecipient(Db4objects.Db4o.Messaging.IMessageRecipient)">ClientServerConfiguration.setMessageRecipient(MessageRecipient)</see>
            , <br/>
            <see cref="T:Db4objects.Db4o.Messaging.IMessageSender">IMessageSender</see>
            ,<br/>
            <see cref="M:Db4objects.Db4o.Config.IClientServerConfiguration.GetMessageSender">Db4objects.Db4o.Config.IClientServerConfiguration.GetMessageSender()
            	</see>
            ,<br/>
            <see cref="!:MessageRecipientWithContext">MessageRecipientWithContext</see>
            <br/>
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Messaging.IMessageRecipient.ProcessMessage(Db4objects.Db4o.Messaging.IMessageContext,System.Object)">
            <summary>the method called upon the arrival of messages.</summary>
            <remarks>the method called upon the arrival of messages.</remarks>
            <param name="context">contextual information for the message.</param>
            <param name="message">the message received.</param>
        </member>
        <member name="T:Db4objects.Db4o.MetaClass">
            <summary>
            Class metadata to be stored to the database file
            Don't obfuscate.
            </summary>
            <remarks>
            Class metadata to be stored to the database file
            Don't obfuscate.
            </remarks>
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="F:Db4objects.Db4o.MetaClass.name">
            <summary>persistent field, don't touch</summary>
        </member>
        <member name="F:Db4objects.Db4o.MetaClass.fields">
            <summary>persistent field, don't touch</summary>
        </member>
        <member name="T:Db4objects.Db4o.MetaField">
            <summary>Field MetaData to be stored to the database file.</summary>
            <remarks>
            Field MetaData to be stored to the database file.
            Don't obfuscate.
            </remarks>
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.MetaIndex">
            <summary>The index record that is written to the database file.</summary>
            <remarks>
            The index record that is written to the database file.
            Don't obfuscate.
            </remarks>
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.P1Object">
            <summary>Kept for 5.7 migration support (PBootRecord depends on it).</summary>
            <remarks>Kept for 5.7 migration support (PBootRecord depends on it).</remarks>
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.PBootRecord">
            <summary>Old database boot record class.</summary>
            <remarks>
            Old database boot record class.
            This class was responsible for storing the last timestamp id,
            for holding a reference to the Db4oDatabase object of the
            ObjectContainer and for holding on to the UUID index.
            This class is no longer needed with the change to the new
            fileheader. It still has to stay here to be able to read
            old databases.
            </remarks>
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.Query.Predicate">
            <summary>Base class for native queries.</summary>
            <remarks>
            Base class for native queries.
            <br /><br />Native Queries provide the ability to run one or more lines
            of code against all instances of a class. Native query expressions should
            return true to mark specific instances as part of the result set.
            db4o will  attempt to optimize native query expressions and run them
            against indexes and without instantiating actual objects, where this is
            possible.<br /><br />
            The syntax of the enclosing object for the native query expression varies
            slightly, depending on the language version used. Here are some examples,
            how a simple native query will look like in some of the programming languages and
            dialects that db4o supports:<br /><br />
            <code>
            <b>// C# .NET 2.0</b><br />
            IList &lt;Cat&gt; cats = db.Query &lt;Cat&gt; (delegate(Cat cat) {<br />
            &#160;&#160;&#160;return cat.Name == "Occam";<br />
            });<br />
            <br />
            <br />
            <b>// Java JDK 5</b><br />
            List &lt;Cat&gt; cats = db.query(new Predicate&lt;Cat&gt;() {<br />
            &#160;&#160;&#160;public boolean match(Cat cat) {<br />
            &#160;&#160;&#160;&#160;&#160;&#160;return cat.getName().equals("Occam");<br />
            &#160;&#160;&#160;}<br />
            });<br />
            <br />
            <br />
            <b>// Java JDK 1.2 to 1.4</b><br />
            List cats = db.query(new Predicate() {<br />
            &#160;&#160;&#160;public boolean match(Cat cat) {<br />
            &#160;&#160;&#160;&#160;&#160;&#160;return cat.getName().equals("Occam");<br />
            &#160;&#160;&#160;}<br />
            });<br />
            <br />
            <br />
            <b>// Java JDK 1.1</b><br />
            ObjectSet cats = db.query(new CatOccam());<br />
            <br />
            public static class CatOccam extends Predicate {<br />
            &#160;&#160;&#160;public boolean match(Cat cat) {<br />
            &#160;&#160;&#160;&#160;&#160;&#160;return cat.getName().equals("Occam");<br />
            &#160;&#160;&#160;}<br />
            });<br />
            <br />
            <br />
            <b>// C# .NET 1.1</b><br />
            IList cats = db.Query(new CatOccam());<br />
            <br />
            public class CatOccam : Predicate {<br />
            &#160;&#160;&#160;public boolean Match(Cat cat) {<br />
            &#160;&#160;&#160;&#160;&#160;&#160;return cat.Name == "Occam";<br />
            &#160;&#160;&#160;}<br />
            });<br />
            </code>
            <br />
            Summing up the above:<br />
            In order to run a Native Query, you can<br />
            - use the delegate notation for .NET 2.0.<br />
            - extend the Predicate class for all other language dialects<br /><br />
            A class that extends Predicate is required to
            implement the #match() / #Match() method, following the native query
            conventions:<br />
            - The name of the method is "#match()" (Java) / "#Match()" (.NET).<br />
            - The method must be public public.<br />
            - The method returns a boolean.<br />
            - The method takes one parameter.<br />
            - The Type (.NET) / Class (Java) of the parameter specifies the extent.<br />
            - For all instances of the extent that are to be included into the
            resultset of the query, the match method should return true. For all
            instances that are not to be included, the match method should return
            false.<br /><br />
            </remarks>
        </member>
        <member name="F:Db4objects.Db4o.Query.Predicate.PredicatemethodName">
            <summary>public for implementation reasons, please ignore.</summary>
            <remarks>public for implementation reasons, please ignore.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Query.Predicate.ExtentType">
            <summary>public for implementation reasons, please ignore.</summary>
            <remarks>public for implementation reasons, please ignore.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Query.Predicate.AppliesTo(System.Object)">
            <summary>public for implementation reasons, please ignore.</summary>
            <remarks>public for implementation reasons, please ignore.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.ArrayInfo">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Core.AbstractReflectArray">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.IReflectArray">
            <summary>Reflection Array representation.</summary>
            <remarks>
            Reflection Array representation
            <br/><br/>See documentation for System.Reflection API.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflector">IReflector</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.IReflectClass">
            <summary>Reflection Class representation.</summary>
            <remarks>
            Reflection Class representation
            <br/><br/>See documentation for System.Reflection API.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflector">IReflector</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflectClass.GetDelegate">
            <summary>Returns the ReflectClass instance being delegated to.</summary>
            <remarks>
            Returns the ReflectClass instance being delegated to.
            If there's no delegation it should return this.
            </remarks>
            <returns>delegate or this</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflectClass.EnsureCanBeInstantiated">
            <summary>
            Calling this method may change the internal state of the class, even if a usable
            constructor has been found on earlier invocations.
            </summary>
            <remarks>
            Calling this method may change the internal state of the class, even if a usable
            constructor has been found on earlier invocations.
            </remarks>
            <returns>true, if instances of this class can be created, false otherwise</returns>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Core.IReflectConstructor">
            <summary>Reflection Constructor representation.</summary>
            <remarks>
            Reflection Constructor representation
            <br/><br/>See documentation for System.Reflection API.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflector">IReflector</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Core.ReflectConstructorSpec">
            <summary>
            a spec holding a constructor, it's arguments
            and information, if the constructor can instantiate
            objects.
            </summary>
            <remarks>
            a spec holding a constructor, it's arguments
            and information, if the constructor can instantiate
            objects.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Core.ReflectConstructorSpec.NewInstance">
            <summary>creates a new instance.</summary>
            <remarks>creates a new instance.</remarks>
            <returns>the newly created instance.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Core.ReflectConstructorSpec.CanBeInstantiated">
            <summary>
            returns true if an instance can be instantiated
            with the constructor, otherwise false.
            </summary>
            <remarks>
            returns true if an instance can be instantiated
            with the constructor, otherwise false.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Core.ReflectorUtils">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericArray">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericArrayClass">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericClass">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericArrayReflector">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericClassBuilder">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.IReflectClassBuilder">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericField">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.IReflectField">
            <summary>Reflection Field representation.</summary>
            <remarks>
            Reflection Field representation
            <br/><br/>See documentation for System.Reflection API.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflector">IReflector</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflectField.GetFieldType">
            <summary>
            The ReflectClass returned by this method should have been
            provided by the parent reflector.
            </summary>
            <remarks>
            The ReflectClass returned by this method should have been
            provided by the parent reflector.
            </remarks>
            <returns>the ReflectClass representing the field type as provided by the parent reflector
            	</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflectField.IndexType">
            <summary>
            The ReflectClass returned by this method should have been
            provided by the parent reflector.
            </summary>
            <remarks>
            The ReflectClass returned by this method should have been
            provided by the parent reflector.
            </remarks>
            <returns>the ReflectClass representing the index type as provided by the parent reflector
            	</returns>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericObject">
            <exclude></exclude>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericObject.Get(System.Int32)">
            <param name="index"></param>
            <returns>the value of the field at index, based on the fields obtained GenericClass.getDeclaredFields
            	</returns>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericReflector">
            <summary>
            db4o provides GenericReflector as a wrapper around specific
            reflector (delegate).
            </summary>
            <remarks>
            db4o provides GenericReflector as a wrapper around specific
            reflector (delegate). GenericReflector is set when an
            ObjectContainer is opened. All subsequent reflector
            calls are routed through this interface.<br/><br/>
            An instance of GenericReflector can be obtained through
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Reflector">Db4objects.Db4o.Ext.IExtObjectContainer.Reflector()
            	</see>
            .<br/><br/>
            GenericReflector keeps list of known classes in memory.
            When the GenericReflector is called, it first checks its list of
            known classes. If the class cannot be found, the task is
            transferred to the delegate reflector. If the delegate fails as
            well, generic objects are created, which hold simulated
            "field values" in an array of objects.<br/><br/>
            Generic reflector makes possible the following usecases:<ul>
            <li>running a db4o server without deploying application classes;</li>
            <li>running db4o on Java dialects without reflection (J2ME CLDC, MIDP);</li>
            <li>easier access to stored objects where classes or fields are not available;</li>
            <li>running refactorings in the reflector;</li>
            <li>building interfaces to db4o from any programming language.</li></ul>
            <br/><br/>
            One of the live usecases is ObjectManager, which uses GenericReflector
            to read C# objects from Java.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.IReflector">
            <summary>root of the reflection implementation API.</summary>
            <remarks>
            root of the reflection implementation API.
            <br/><br/>The open reflection interface is supplied to allow to implement
            custom reflection functionality.<br/><br/>
            Use
            <see cref="!:IConfiguration.ReflectWith">
            Db4o.Configure().ReflectWith(IReflect reflector)
            </see>
            to register the use of your implementation before opening database
            files.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflector.Array">
            <summary>
            returns an ReflectArray object.
            </summary>
            <remarks>
            returns an ReflectArray object.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflector.ForClass(System.Type)">
            <summary>returns an ReflectClass for a Class</summary>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflector.ForName(System.String)">
            <summary>
            returns an ReflectClass class reflector for a class name or null
            if no such class is found
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflector.ForObject(System.Object)">
            <summary>returns an ReflectClass for an object or null if the passed object is null.
            	</summary>
            <remarks>returns an ReflectClass for an object or null if the passed object is null.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.#ctor(Db4objects.Db4o.Internal.Transaction,Db4objects.Db4o.Reflect.IReflector)">
            <summary>Creates an instance of GenericReflector</summary>
            <param name="trans">transaction</param>
            <param name="delegateReflector">
            delegate reflector,
            providing specific reflector functionality. For example
            </param>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.DeepClone(System.Object)">
            <summary>Creates a clone of provided object</summary>
            <param name="obj">object to copy</param>
            <returns>copy of the submitted object</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.HasTransaction">
            <summary>If there is a transaction assosiated with the current refector.</summary>
            <remarks>If there is a transaction assosiated with the current refector.</remarks>
            <returns>true if there is a transaction assosiated with the current refector.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.SetTransaction(Db4objects.Db4o.Internal.Transaction)">
            <summary>Associated a transaction with the current reflector.</summary>
            <remarks>Associated a transaction with the current reflector.</remarks>
            <param name="trans"></param>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.Array">
            <returns>generic reflect array instance.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.ForClass(System.Type)">
            <summary>Returns a ReflectClass instance for the specified class</summary>
            <param name="clazz">class</param>
            <returns>a ReflectClass instance for the specified class</returns>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflectClass">Db4objects.Db4o.Reflect.IReflectClass
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.ForName(System.String)">
            <summary>Returns a ReflectClass instance for the specified class name</summary>
            <param name="className">class name</param>
            <returns>a ReflectClass instance for the specified class name</returns>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflectClass">Db4objects.Db4o.Reflect.IReflectClass
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.ForObject(System.Object)">
            <summary>Returns a ReflectClass instance for the specified class object</summary>
            <param name="obj">class object</param>
            <returns>a ReflectClass instance for the specified class object</returns>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflectClass">Db4objects.Db4o.Reflect.IReflectClass
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.GetDelegate">
            <summary>Returns delegate reflector</summary>
            <returns>delegate reflector</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.IsCollection(Db4objects.Db4o.Reflect.IReflectClass)">
            <summary>Determines if a candidate ReflectClass is a collection</summary>
            <param name="candidate">candidate ReflectClass</param>
            <returns>true  if a candidate ReflectClass is a collection.</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.RegisterCollection(System.Type)">
            <summary>Register a class as a collection</summary>
            <param name="clazz">class to be registered</param>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.RegisterCollection(Db4objects.Db4o.Reflect.IReflectClassPredicate)">
            <summary>Register a predicate as a collection</summary>
            <param name="predicate">predicate to be registered</param>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.Register(Db4objects.Db4o.Reflect.Generic.GenericClass)">
            <summary>Register a class</summary>
            <param name="clazz">class</param>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.KnownClasses">
            <summary>Returns an array of classes known to the reflector</summary>
            <returns>an array of classes known to the reflector</returns>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.RegisterPrimitiveClass(System.Int32,System.String,Db4objects.Db4o.Reflect.Generic.IGenericConverter)">
            <summary>Registers primitive class</summary>
            <param name="id">class id</param>
            <param name="name">class name</param>
            <param name="converter">class converter</param>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.Generic.GenericReflector.SetParent(Db4objects.Db4o.Reflect.IReflector)">
            <summary>method stub: generic reflector does not have a parent</summary>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.IReflectClassPredicate">
            <summary>Predicate representation.</summary>
            <remarks>Predicate representation.</remarks>
            <seealso cref="T:Db4objects.Db4o.Query.Predicate">Db4objects.Db4o.Query.Predicate</seealso>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflector">IReflector</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflectClassPredicate.Match(Db4objects.Db4o.Reflect.IReflectClass)">
            <summary>Match method definition.</summary>
            <remarks>
            Match method definition. Used to select correct
            results from an object set.
            </remarks>
            <param name="item">item to be matched to the criteria</param>
            <returns>true, if the requirements are met</returns>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.GenericVirtualField">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.IGenericConverter">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Generic.KnownClassesRepository">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.IReflectMethod">
            <summary>Reflection Method representation.</summary>
            <remarks>
            Reflection Method representation
            <br/><br/>See documentation for System.Reflection API.
            </remarks>
            <seealso cref="T:Db4objects.Db4o.Reflect.IReflector">IReflector</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Reflect.IReflectMethod.Invoke(System.Object,System.Object[])">
            <exception cref="T:Db4objects.Db4o.Internal.ReflectException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.MultidimensionalArrayInfo">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Rename">
            <summary>
            Renaming actions are stored to the database file to make
            sure that they are only performed once.
            </summary>
            <remarks>
            Renaming actions are stored to the database file to make
            sure that they are only performed once.
            </remarks>
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.Replication.IReplicationConflictHandler">
            <summary>
            will be called by a
            <see cref="T:Db4objects.Db4o.Replication.IReplicationProcess">IReplicationProcess</see>
            upon
            replication conflicts. Conflicts occur whenever
            <see cref="M:Db4objects.Db4o.Replication.IReplicationProcess.Replicate(System.Object)">IReplicationProcess.Replicate(object)
            	</see>
            is called with an object that
            was modified in both ObjectContainers since the last replication run between
            the two.
            </summary>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationConflictHandler.ResolveConflict(Db4objects.Db4o.Replication.IReplicationProcess,System.Object,System.Object)">
            <summary>the callback method to be implemented to resolve a conflict.</summary>
            <remarks>
            the callback method to be implemented to resolve a conflict. <br/>
            <br/>
            </remarks>
            <param name="replicationProcess">
            the
            <see cref="T:Db4objects.Db4o.Replication.IReplicationProcess">IReplicationProcess</see>
            for which this
            ReplicationConflictHandler is registered
            </param>
            <param name="a">the object modified in the peerA ObjectContainer</param>
            <param name="b">the object modified in the peerB ObjectContainer</param>
            <returns>
            the object (a or b) that should prevail in the conflict or null,
            if no action is to be taken. If this would violate the direction
            set with
            <see cref="M:Db4objects.Db4o.Replication.IReplicationProcess.SetDirection(Db4objects.Db4o.IObjectContainer,Db4objects.Db4o.IObjectContainer)">IReplicationProcess.SetDirection(Db4objects.Db4o.IObjectContainer, Db4objects.Db4o.IObjectContainer)
            	</see>
            no action will be taken.
            </returns>
            <seealso cref="M:Db4objects.Db4o.Replication.IReplicationProcess.PeerA">IReplicationProcess.PeerA()</seealso>
            <seealso cref="M:Db4objects.Db4o.Replication.IReplicationProcess.PeerB">IReplicationProcess.PeerB()</seealso>
        </member>
        <member name="T:Db4objects.Db4o.Replication.IReplicationProcess">
            <summary>db4o replication interface.</summary>
            <remarks>db4o replication interface.</remarks>
            <seealso cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.ReplicationBegin(Db4objects.Db4o.IObjectContainer,Db4objects.Db4o.Replication.IReplicationConflictHandler)">Db4objects.Db4o.Ext.IExtObjectContainer.ReplicationBegin(Db4objects.Db4o.IObjectContainer, IReplicationConflictHandler)
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.CheckConflict(System.Object)">
            <summary>
            checks if an object has been modified in both ObjectContainers involved
            in the replication process since the last time the two ObjectContainers
            were replicated.
            </summary>
            <remarks>
            checks if an object has been modified in both ObjectContainers involved
            in the replication process since the last time the two ObjectContainers
            were replicated.
            </remarks>
            <param name="obj">- the object to check for a conflict.</param>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.Commit">
            <summary>commits the replication task to both involved ObjectContainers.</summary>
            <remarks>
            commits the replication task to both involved ObjectContainers.
            <br/><br/>Call this method after replication is completed to
            write all changes back to the database files. This method
            synchronizes both ObjectContainers by setting the transaction
            serial number
            <see cref="M:Db4objects.Db4o.Ext.IExtObjectContainer.Version">Db4objects.Db4o.Ext.IExtObjectContainer.Version()
            	</see>
            on both
            ObjectContainers to be equal
            to the higher version number among the two. A record with
            information about this replication task, including the
            synchronized version number is stored to both ObjectContainers
            to allow future incremental replication.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.PeerA">
            <summary>returns the "peerA" ObjectContainer involved in this ReplicationProcess.
            	</summary>
            <remarks>returns the "peerA" ObjectContainer involved in this ReplicationProcess.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.PeerB">
            <summary>returns the "peerB" ObjectContainer involved in this ReplicationProcess.
            	</summary>
            <remarks>returns the "peerB" ObjectContainer involved in this ReplicationProcess.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.Replicate(System.Object)">
            <summary>replicates an object.</summary>
            <remarks>
            replicates an object.
            <br /><br />By default the version number of the object is checked in
            both ObjectContainers involved in the replication process. If the
            version number has not changed since the last time the two
            ObjectContainers were replicated
            </remarks>
            <param name="obj"></param>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.Rollback">
            <summary>ends a replication task without committing any changes.</summary>
            <remarks>ends a replication task without committing any changes.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.SetDirection(Db4objects.Db4o.IObjectContainer,Db4objects.Db4o.IObjectContainer)">
            <summary>
            modifies the replication policy, what to do on a call to
            <see cref="M:Db4objects.Db4o.Replication.IReplicationProcess.Replicate(System.Object)">Replicate(object)</see>
            .
            <br/><br/>If no direction is set, the replication process will be bidirectional by
            default.
            </summary>
            <param name="relicateFrom">the ObjectContainer to replicate from</param>
            <param name="replicateTo">the ObjectContainer to replicate to</param>
        </member>
        <member name="M:Db4objects.Db4o.Replication.IReplicationProcess.WhereModified(Db4objects.Db4o.Query.IQuery)">
            <summary>
            adds a constraint to the passed Query to query only for objects that
            were modified since the last replication process between the two
            ObjectContainers involved in this replication process.
            </summary>
            <remarks>
            adds a constraint to the passed Query to query only for objects that
            were modified since the last replication process between the two
            ObjectContainers involved in this replication process.
            </remarks>
            <param name="query">the Query to be constrained</param>
        </member>
        <member name="T:Db4objects.Db4o.StaticClass">
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.StaticField">
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.TA.IActivatableInstrumented">
            <summary>
            Marker interface to declare a class already implements the required TA/TP hooks
            and does not want to be instrumented further.
            </summary>
            <remarks>
            Marker interface to declare a class already implements the required TA/TP hooks
            and does not want to be instrumented further.
            </remarks>
        </member>
        <member name="T:Db4objects.Db4o.TA.IRollbackStrategy">
            <summary>Interface defining rollback behavior when Transparent Persistence mode is on.
            	</summary>
            <remarks>Interface defining rollback behavior when Transparent Persistence mode is on.
            	</remarks>
        </member>
        <member name="M:Db4objects.Db4o.TA.IRollbackStrategy.Rollback(Db4objects.Db4o.IObjectContainer,System.Object)">
            <summary>Method to be called per TP-enabled object when the transaction is rolled back.
            	</summary>
            <remarks>Method to be called per TP-enabled object when the transaction is rolled back.
            	</remarks>
            <param name="container">current ObjectContainer</param>
            <param name="obj">TP-enabled object</param>
        </member>
        <member name="T:Db4objects.Db4o.TA.TransactionalActivator">
            <summary>
            An
            <see cref="T:Db4objects.Db4o.Activation.IActivator">Db4objects.Db4o.Activation.IActivator
            	</see>
            implementation that activates an object on a specific
            transaction.
            </summary>
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.TA.TransparentActivationSupport">
            <summary>
            Configuration item that enables Transparent Activation Mode for this
            session.
            </summary>
            <remarks>
            Configuration item that enables Transparent Activation Mode for this
            session. TA mode should be switched on explicitly for manual TA implementation:
            <br/><br/>
            commonConfiguration.Add(new TransparentActivationSupport());
            </remarks>
            <seealso cref="T:Db4objects.Db4o.TA.TransparentPersistenceSupport"/>
        </member>
        <member name="M:Db4objects.Db4o.TA.TransparentActivationSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)">
            <summary>
            Configures the just opened ObjectContainer by setting event listeners,
            which will be triggered when activation or de-activation is required.
            </summary>
            <remarks>
            Configures the just opened ObjectContainer by setting event listeners,
            which will be triggered when activation or de-activation is required.
            </remarks>
            <param name="container">the ObjectContainer to configure</param>
            <seealso cref="M:Db4objects.Db4o.TA.TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)">TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)
            	</seealso>
        </member>
        <member name="T:Db4objects.Db4o.TA.TransparentPersistenceSupport">
            <summary>
            Enables Transparent Persistence and Transparent Activation behaviours for
            the current session.
            </summary>
            <remarks>
            Enables Transparent Persistence and Transparent Activation behaviours for
            the current session.
            <br/><br/>
            commonConfiguration.Add(new TransparentPersistenceSupport());
            </remarks>
            <seealso cref="T:Db4objects.Db4o.TA.TransparentActivationSupport">Db4objects.Db4o.TA.TransparentActivationSupport
            </seealso>
        </member>
        <member name="M:Db4objects.Db4o.TA.TransparentPersistenceSupport.#ctor(Db4objects.Db4o.TA.IRollbackStrategy)">
            <summary>Creates a new instance of TransparentPersistenceSupport class</summary>
            <param name="rollbackStrategy">
            RollbackStrategy interface implementation, which
            defines the actions to be taken on the object when the transaction is rolled back.
            </param>
        </member>
        <member name="M:Db4objects.Db4o.TA.TransparentPersistenceSupport.#ctor">
            <summary>
            Creates a new instance of TransparentPersistenceSupport class
            with no rollback strategies defined.
            </summary>
            <remarks>
            Creates a new instance of TransparentPersistenceSupport class
            with no rollback strategies defined.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.TA.TransparentPersistenceSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)">
            <summary>Configures current ObjectContainer to support Transparent Activation and Transparent Persistence
            	</summary>
            <seealso cref="M:Db4objects.Db4o.TA.TransparentActivationSupport.Apply(Db4objects.Db4o.Internal.IInternalObjectContainer)"></seealso>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.CollectionTypeHandler">
            <summary>TypeHandler for Collections.</summary>
            <remarks>
            TypeHandler for Collections.
            On the .NET side, usage is restricted to instances of IList.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.CollectionTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.IInstantiatingTypeHandler.WriteInstantiation(Db4objects.Db4o.Marshall.IWriteContext,System.Object)">
            <summary>gets called when an object is to be written to the database.</summary>
            <remarks>
            gets called when an object is to be written to the database.
            The method must only write data necessary to re instantiate the object, usually
            the immutable bits of information held by the object. For value
            types that means their complete state.
            Mutable state (only allowed in reference types) must be handled
            during
            <see cref="M:Db4objects.Db4o.Typehandlers.IReferenceTypeHandler.Activate(Db4objects.Db4o.Marshall.IReferenceActivationContext)">IReferenceTypeHandler.Activate(Db4objects.Db4o.Marshall.IReferenceActivationContext)
            	</see>
            </remarks>
            <param name="context"></param>
            <param name="obj">the object</param>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.ITypeFamilyTypeHandler">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.ITypeHandlerPredicate">
            <summary>
            Predicate to be able to select if a specific TypeHandler is
            applicable for a specific Type.
            </summary>
            <remarks>
            Predicate to be able to select if a specific TypeHandler is
            applicable for a specific Type.
            </remarks>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.ITypeHandlerPredicate.Match(Db4objects.Db4o.Reflect.IReflectClass)">
            <summary>
            return true if a TypeHandler is to be used for a specific
            Type
            </summary>
            <param name="classReflector">
            the Type passed by db4o that is to
            be tested by this predicate.
            </param>
            <returns>
            true if the TypeHandler is to be used for a specific
            Type.
            </returns>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.IgnoreFieldsTypeHandler">
            <summary>Typehandler that ignores all fields on a class</summary>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.IgnoreFieldsTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.Internal.KeyValueHandlerPair">
            <exclude></exclude>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.MapTypeHandler">
            <summary>Typehandler for classes that implement IDictionary.</summary>
            <remarks>Typehandler for classes that implement IDictionary.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Typehandlers.MapTypeHandler.Delete(Db4objects.Db4o.Internal.Delete.IDeleteContext)">
            <exception cref="T:Db4objects.Db4o.Ext.Db4oIOException"></exception>
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.SingleClassTypeHandlerPredicate">
            <summary>allows installing a Typehandler for a single class.</summary>
            <remarks>allows installing a Typehandler for a single class.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Types.IDb4oCollection">
            <summary>base interface for db4o collections</summary>
        </member>
        <member name="M:Db4objects.Db4o.Types.IDb4oCollection.ActivationDepth(System.Int32)">
            <summary>configures the activation depth for objects returned from this collection.
            	</summary>
            <remarks>
            configures the activation depth for objects returned from this collection.
            <br /><br />Specify a value less than zero to use the default activation depth
            configured for the ObjectContainer or for individual objects.
            </remarks>
            <param name="depth">the desired depth</param>
        </member>
        <member name="M:Db4objects.Db4o.Types.IDb4oCollection.DeleteRemoved(System.Boolean)">
            <summary>
            configures objects are to be deleted from the database file if they are
            removed from this collection.
            </summary>
            <remarks>
            configures objects are to be deleted from the database file if they are
            removed from this collection.
            <br /><br />Default value: <code>false</code>
            </remarks>
            <param name="flag">the desired setting</param>
        </member>
        <member name="T:Db4objects.Db4o.Types.IDb4oCollections">
            <summary>factory and other methods for database-aware collections.</summary>
            <remarks>factory and other methods for database-aware collections.</remarks>
        </member>
        <member name="M:Db4objects.Db4o.Types.IDb4oCollections.NewLinkedList">
            <summary>creates a new database-aware linked list.</summary>
            <remarks>
            creates a new database-aware linked list.
            <br/><br/>Usage:<br/>
            - declare an IList variable in your persistent class.<br/>
            - fill this variable with this method.<br/><br/>
            <b>Example:</b><br/><br/>
            <code>
            <pre>
            class MyClass{
            IList myList;
            }
            MyClass myObject = new MyClass();
            myObject.myList = objectContainer.Ext().Collections().NewLinkedList();
            </pre>
            </code><br/><br/>
            
            </remarks>
            <returns>
            
            <see cref="T:Db4objects.Db4o.Types.IDb4oList">IDb4oList</see>
            
            </returns>
            <seealso cref="T:Db4objects.Db4o.Types.IDb4oList">IDb4oList</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Types.IDb4oCollections.NewHashMap(System.Int32)">
            <summary>creates a new database-aware HashMap.</summary>
            <remarks>
            creates a new database-aware HashMap.
            <br/><br/>
            This map will call the HashCode() method on the key objects to calculate the
            hash value. Since the hash value is stored to the ObjectContainer, key objects
            will have to return the same HashCode() value in every CLR session.
            <br/><br/>
            Usage:<br/>
            - declare an IDictionary variable in your persistent class.<br/>
            - fill the variable with this method.<br/><br/>
            <b>Example:</b><br/><br/>
            <code>
            <pre>
            class MyClass{
            IDictionary dict;
            }
            MyClass myObject = new MyClass();
            myObject.dict = objectContainer.Ext().Collections().NewHashMap(0);
            </pre>
            </code><br/><br/>
            </remarks>
            <param name="initialSize">the initial size of the HashMap</param>
            <returns>
            <see cref="T:Db4objects.Db4o.Types.IDb4oMap">IDb4oMap</see>
            </returns>
            <seealso cref="T:Db4objects.Db4o.Types.IDb4oMap">IDb4oMap</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Types.IDb4oCollections.NewIdentityHashMap(System.Int32)">
            <summary>creates a new database-aware IdentityHashMap.</summary>
            <remarks>
            creates a new database-aware IdentityHashMap.
            <br/><br/>
            Only first class objects already stored to the ObjectContainer (objects with a db4o ID)
            can be used as keys for this type of Map. The internal db4o ID will be used as
            the hash value.
            <br/><br/>
            Usage:<br/>
            - declare an IDictionary variable in your persistent class.<br/>
            - fill the variable with this method.<br/><br/>
            <b>Example:</b><br/><br/>
            <code>
            <pre>
            public class MyClass{
            public IDictionary  dict;
            }
            MyClass myObject = new MyClass();
            myObject.dict = objectContainer.Ext().Collections().NewIdentityHashMap(0);
            </pre>
            </code><br/><br/>
            
            </remarks>
            <param name="initialSize">the initial size of the IdentityHashMap</param>
            <returns>
            
            <see cref="T:Db4objects.Db4o.Types.IDb4oMap">IDb4oMap</see>
            </returns>
            <seealso cref="T:Db4objects.Db4o.Types.IDb4oMap">IDb4oMap</seealso>
        </member>
        <!-- Badly formed XML comment ignored for member "T:Db4objects.Db4o.Types.IDb4oList" -->
        <!-- Badly formed XML comment ignored for member "T:Db4objects.Db4o.Types.IDb4oMap" -->
        <member name="T:Db4objects.Db4o.User">
            <exclude></exclude>
            <persistent></persistent>
        </member>
        <member name="T:Db4objects.Db4o.Config.TCultureInfo">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Config.TDictionary">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Config.TList">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Config.TQueue">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Config.TStack">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Config.TTransient">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Config.TType">
            <exclude />
        </member>
        <member name="M:Db4objects.Db4o.Defragment.AvailableTypeFilter.Accept(Db4objects.Db4o.Ext.IStoredClass)">
            <param name="storedClass">StoredClass instance to be checked</param>
            <returns>true, if the given StoredClass instance should be accepted, false otherwise.
            	</returns>
        </member>
        <member name="T:Db4objects.Db4o.Diagnostic.DiagnosticToTrace">
            <summary>prints Diagnostic messsages to the Console.</summary>
            <remarks>
            prints Diagnostic messsages to System.Diagnostics.Trace.
            Install this
            <see cref="T:Db4objects.Db4o.Diagnostic.IDiagnosticListener">Db4objects.Db4o.Diagnostic.IDiagnosticListener
            	</see>
            with: <br/>
            <code>commonConfig.Diagnostic.AddListener(new DiagnosticToTrace());</code><br/>
            </remarks>
            <seealso cref="!:Db4objects.Db4o.Diagnostic.DiagnosticConfiguration">Db4objects.Db4o.Diagnostic.DiagnosticConfiguration
            	</seealso>
        </member>
        <member name="M:Db4objects.Db4o.Diagnostic.DiagnosticToTrace.OnDiagnostic(Db4objects.Db4o.Diagnostic.IDiagnostic)">
            <summary>redirects Diagnostic messages to System.Diagnostics.Trace</summary>
            <remarks>redirects Diagnostic messages to the Console.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Dynamic">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Internal.Platform4">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.GenericObjectSetFacade`1">
            <summary>
            List based objectSet implementation
            </summary>
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Internal.Query.ObjectSetFacade">
            <summary>
            List based objectSet implementation
            </summary>
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Net.NetClass">
            <summary>Reflection implementation for Class to map to .NET reflection.</summary>
            <remarks>Reflection implementation for Class to map to .NET reflection.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Net.NetConstructor">
            <remarks>Reflection implementation for Constructor to map to .NET reflection.</remarks>
        </member>
        <member name="T:Db4objects.Db4o.TransientAttribute">
            <summary>
            Marks a field or event as transient.
            </summary>
            <remarks>
            Transient fields are not stored by db4o.
            <br />
            If you don't want a field to be stored by db4o,
            simply mark it with this attribute.
            </remarks>
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Typehandlers.GuidTypeHandler">
            <summary>
            DB4O type handler for efficiently storing and activating System.Guid values.
            </summary>
            <author>Judah Himango</author>
        </member>
        <member name="T:Db4objects.Db4o.Compat">
            <exclude />
        </member>
        <member name="T:Db4objects.Db4o.Reflect.Net.SerializationConstructor">
            <summary>Constructs objects by using System.Runtime.Serialization.FormatterServices.GetUninitializedObject
            and bypasses calls to user contructors this way. Not available on CompactFramework
            </summary>
        </member>
        <member name="T:Db4objects.Db4o.Config.TSerializable">
            <summary>
            translator for types that are marked with the Serializable attribute.
            The Serializable translator is provided to allow persisting objects that
            do not supply a convenient constructor. The use of this translator is
            recommended only if:<br />
            - the persistent type will never be refactored<br />
            - querying for type members is not necessary<br />
            </summary>
        </member>
    </members>
</doc>
